RuleManagementService (Kuali Student 2.0.0-M9-SNAPSHOT API)

All Superinterfaces:

TranslateBusinessMethods

All Known Implementing Classes:

KSRuleManagementServiceImpl
```
public interface RuleManagementService
extends TranslateBusinessMethods
```
The rule maintenance service operations facilitate management of rules and associated information.

Author:

Kuali Rice Team (rice.collab@kuali.org)

Method Summary

Methods
Modifier and Type	Method and Description
`ActionDefinition`	`createAction(ActionDefinition actionDefinition)` Create Action
`AgendaDefinition`	`createAgenda(AgendaDefinition agendaDefinition)` Create Agenda and an empty first item
`AgendaItemDefinition`	`createAgendaItem(AgendaItemDefinition agendaItemDefinition)` Create AgendaItem
`ContextDefinition`	`createContext(ContextDefinition contextDefinition)` Create Context
`NaturalLanguageTemplate`	`createNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate)` This will create a `NaturalLanguageTemplate` exactly like the parameter passed in except the id will be assigned and create date/user will be set.
`NaturalLanguageUsage`	`createNaturalLanguageUsage(NaturalLanguageUsage naturalLanguageUsage)` Create NaturalLanguageUsage
`PropositionDefinition`	`createProposition(PropositionDefinition propositionDefinition)` Create a Proposition
`ReferenceObjectBinding`	`createReferenceObjectBinding(ReferenceObjectBinding referenceObjectDefinition)` Create RefObject-KRMS object binding
`RuleDefinition`	`createRule(RuleDefinition ruleDefinition)` Create Rule
`void`	`deleteAction(String id)` Delete the specified Action
`void`	`deleteAgenda(String id)` Delete the specified Agenda
`void`	`deleteAgendaItem(String id)` Delete the specified AgendaItem
`void`	`deleteContext(String id)` Delete the specified Context
`void`	`deleteNaturalLanguageTemplate(String naturalLanguageTemplateId)` Delete the `NaturalLanguageTemplate` with the given id.
`void`	`deleteNaturalLanguageUsage(String naturalLanguageUsageId)` Delete NaturalLanguageUsage
`void`	`deleteProposition(String id)` Delete the Proposition
`void`	`deleteReferenceObjectBinding(String id)` Delete the specified ReferenceObjectBinding object
`void`	`deleteRule(String id)` Delete the specified Rule
`List<String>`	`findActionIds(QueryByCriteria queryByCriteria)` Query for Action ids based on the given search criteria which is a Map of Action field names to values.
`List<String>`	`findAgendaIds(QueryByCriteria queryByCriteria)` Query for Agenda ids based on the given search criteria which is a Map of Agenda field names to values.
`List<String>`	`findContextIds(QueryByCriteria queryByCriteria)` Query for Context ids based on the given search criteria which is a Map of Context field names to values.
`AgendaDefinition`	`findCreateAgenda(AgendaDefinition agendaDefinition)` Create Agenda if not found by contextId and name
`ContextDefinition`	`findCreateContext(ContextDefinition contextDefinition)` find Create Context Searches for an existing context with the same name and namespace and returns it otherwise it creates the context.
`NaturalLanguageTemplate`	`findNaturalLanguageTemplateByLanguageCodeTypeIdAndNluId(String languageCode, String typeId, String naturalLanguageUsageId)`
`List<NaturalLanguageTemplate>`	`findNaturalLanguageTemplatesByLanguageCode(String languageCode)` Finds all the natural language templates for a particular language
`List<NaturalLanguageTemplate>`	`findNaturalLanguageTemplatesByNaturalLanguageUsage(String naturalLanguageUsageId)` Find all the natural language templates for a particular usage
`List<NaturalLanguageTemplate>`	`findNaturalLanguageTemplatesByTemplate(String template)` Find the natural language template using the actual text of the template.
`List<NaturalLanguageTemplate>`	`findNaturalLanguageTemplatesByType(String typeId)` Find all the natural language templates of a particular type Template types are keys that identify the message that is to be expressed in different languages and in different usage scenarios
`List<String>`	`findPropositionIds(QueryByCriteria queryByCriteria)` Query for Proposition ids based on the given search criteria which is a Map of Proposition field names to values.
`List<String>`	`findReferenceObjectBindingIds(QueryByCriteria queryByCriteria)` Query for ReferenceObjectBinding ids based on the given search criteria which is a Map of ReferenceObjectBinding field names to values.
`List<ReferenceObjectBinding>`	`findReferenceObjectBindingsByKrmsDiscriminatorType(String referenceObjectKrmsDiscriminatorType)` Retrieves list of ReferenceObjectBinding objects for the given krms obj discriminator type
`List<ReferenceObjectBinding>`	`findReferenceObjectBindingsByKrmsObject(String krmsObjectId)` Retrieves list of ReferenceObjectBinding objects for the given KRMS obj id.
`List<ReferenceObjectBinding>`	`findReferenceObjectBindingsByReferenceDiscriminatorType(String referenceObjectReferenceDiscriminatorType)` Retrieves list of ReferenceObjectBinding objects for the given ref obj discriminator type
`List<ReferenceObjectBinding>`	`findReferenceObjectBindingsByReferenceObject(String referenceObjectReferenceDiscriminatorType, String referenceObjectId)` Retrieves list of ReferenceObjectBinding objects for the given obj discriminator type and reference object id
`List<ReferenceObjectBinding>`	`findReferenceObjectBindingsByReferenceObjectIds(String referenceObjectReferenceDiscriminatorType, List<String> referenceObjectIds)` Retrieves list of ReferenceObjectBinding objects for the given obj discriminator type and reference object ids
`List<String>`	`findRuleIds(QueryByCriteria queryByCriteria)` Query for Rule ids based on the given search criteria which is a Map of Rule field names to values.
`ActionDefinition`	`getAction(String actionId)` Retrieves the action for the given actionId.
`List<ActionDefinition>`	`getActions(List<String> actionIds)` Retrieves all of the actions for the given list of actionIds.
`AgendaDefinition`	`getAgenda(String id)` Retrieve Agenda for the specified id
`AgendaDefinition`	`getAgendaByNameAndContextId(String name, String contextId)` Retrieves an Agenda from the repository based on the provided agenda name and context id.
`AgendaItemDefinition`	`getAgendaItem(String id)` Retrieve AgendaItem by the specified identifier
`List<AgendaItemDefinition>`	`getAgendaItemsByContext(String contextId)` Retrieve AgendaItems associated with a context
`List<AgendaItemDefinition>`	`getAgendaItemsByType(String typeId)` Retrieve AgendaItems by specified type
`List<AgendaItemDefinition>`	`getAgendaItemsByTypeAndContext(String typeId, String contextId)` Retrieve AgendaItems by type and context
`List<AgendaDefinition>`	`getAgendasByContext(String contextId)` Retrieve Agendas associated with the specified context
`List<AgendaDefinition>`	`getAgendasByType(String typeId)` Retrieve Agendas of the specified type
`List<AgendaDefinition>`	`getAgendasByTypeAndContext(String typeId, String contextId)` Retrieve Agendas of the specified type and context
`AgendaTreeDefinition`	`getAgendaTree(String agendaId)` Retrieves the agenda tree for the given agendaId.
`List<AgendaTreeDefinition>`	`getAgendaTrees(List<String> agendaIds)` Retrieves all of the agendas trees for the given list of agendaIds.
`ContextDefinition`	`getContext(String id)` Retrieve Context for the specified id
`ContextDefinition`	`getContextByNameAndNamespace(String name, String namespace)` Retrieves an Context from the repository based on the provided context name and namespace.
`NaturalLanguageTemplate`	`getNaturalLanguageTemplate(String naturalLanguageTemplateId)` Retrieves a NaturalLanguageTemplate from the repository based on the given id.
`NaturalLanguageUsage`	`getNaturalLanguageUsage(String id)` Retrieve NaturalLanguageUsage specified by the identifier
`NaturalLanguageUsage`	`getNaturalLanguageUsageByNameAndNamespace(String name, String namespace)` Retrieve NaturalLanguageUsage specified by name and namespace
`List<NaturalLanguageUsage>`	`getNaturalLanguageUsagesByNamespace(String namespace)` Translates and retrieves a NaturalLanguage for a given KRMS object (e.g, proposition or agenda), NaturalLanguage usage type (context) and language into natural language
`PropositionDefinition`	`getProposition(String id)` Retrieve Proposition specified by the identifier
`Set<PropositionDefinition>`	`getPropositionsByRule(String ruleId)` Retrieve Propositions associated with the specified Rule
`Set<PropositionDefinition>`	`getPropositionsByType(String typeId)` Retrieve Propositions of the specified type
`ReferenceObjectBinding`	`getReferenceObjectBinding(String id)` Retrieve referenceObjectBinding given a specific id
`List<ReferenceObjectBinding>`	`getReferenceObjectBindings(List<String> ids)` Retrieve list of ReferenceObjectBinding objects given ids
`RuleDefinition`	`getRule(String ruleId)` Retrieves the rule for the given ruleId.
`RuleDefinition`	`getRuleByNameAndNamespace(String name, String namespace)` Retrieves an Rule from the repository based on the provided rule name and namespace.
`List<RuleDefinition>`	`getRules(List<String> ruleIds)` Retrieves all of the rules for the given list of ruleIds.
`ContextDefinition`	`selectContext(ContextSelectionCriteria contextSelectionCriteria)` Locates a ContextDefinition based on the given map of context qualifiers.
`String`	`translateNaturalLanguageForObject(String naturalLanguageUsageId, String typeId, String krmsObjectId, String languageCode)` Translates and retrieves a NaturalLanguage for a given KRMS object (e.g, proposition or agenda), NaturalLanguage usage type (context) and language into natural language TODO: Add appropriate caching annotation
`List<NaturalLanguage>`	`translateNaturalLanguageForObjects(String naturalLanguageUsageId, String typeId, List<String> krmsObjectIds, String languageCode)` Translates and retrieves a NaturalLanguage for a list of KRMS objects (e.g, propositions or agendas), NaturalLanguage usage type (context) and language into natural language
`String`	`translateNaturalLanguageForProposition(String naturalLanguageUsageId, PropositionDefinition propositionDefinintion, String languageCode)` Retrieve all the NaturalLanguageUsages
`NaturalLanguageTree`	`translateNaturalLanguageTreeForProposition(String naturalLanguageUsageId, PropositionDefinition propositionDefinintion, String languageCode)` Translates NaturalLanguage for a given proposition, returning a tree of the NaturalLanguage.
`void`	`updateAction(ActionDefinition actionDefinition)` Update the Action specified by the identifier in the DTO
`void`	`updateAgenda(AgendaDefinition agendaDefinition)` Update the Agenda specified by the identifier in the input DTO
`void`	`updateAgendaItem(AgendaItemDefinition agendaItemDefinition)` Update an AgendaItem
`void`	`updateContext(ContextDefinition contextDefinition)` Update the Context specified by the identifier in the input DTO
`void`	`updateNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate)` This will update an existing `NaturalLanguageTemplate`.
`void`	`updateNaturalLanguageUsage(NaturalLanguageUsage naturalLanguageUsage)` Update NaturalLanguageUsage
`void`	`updateProposition(PropositionDefinition propositionDefinition)` Update the Proposition
`void`	`updateReferenceObjectBinding(ReferenceObjectBinding referenceObjectBindingDefinition)` Update the ReferenceObjectBinding object specified by the identifier in the given DTO
`void`	`updateRule(RuleDefinition ruleDefinition)` Update the Rule specified by the identifier in the DTO

- Method Detail
  - createReferenceObjectBinding
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
            allEntries=true)
ReferenceObjectBinding createReferenceObjectBinding(ReferenceObjectBinding referenceObjectDefinition)
                                                    throws RiceIllegalArgumentException
```
    Create RefObject-KRMS object binding
    
    Parameters:
    referenceObjectDefinition - data for the new ReferenceObjectBinding to be created
    
    Returns:
    newly created ReferenceObjectBinding
    
    Throws:
    
    RiceIllegalArgumentException - if the given referenceObjectDefinition is null or invalid
  - getReferenceObjectBinding
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
           key="\'id=\' + #p0")
ReferenceObjectBinding getReferenceObjectBinding(String id)
                                                 throws RiceIllegalArgumentException
```
    Retrieve referenceObjectBinding given a specific id
    
    Parameters:
    id - identifier of the ReferenceObjectBinding to be retrieved
    
    Returns:
    a ReferenceObjectBinding with the given id value
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is blank or invalid
  - getReferenceObjectBindings
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
           key="\'ids=\' + #p0")
List<ReferenceObjectBinding> getReferenceObjectBindings(List<String> ids)
                                                        throws RiceIllegalArgumentException
```
    Retrieve list of ReferenceObjectBinding objects given ids
    
    Parameters:
    ids - identifiers of the ReferenceObjectBinding to be retrieved
    
    Returns:
    list of ReferenceObjectBinding objects for the given ids
    
    Throws:
    
    RiceIllegalArgumentException - if one or more ids in the give list is blank or invalid
  - findReferenceObjectBindingsByReferenceDiscriminatorType
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
           key="\'referenceObjectReferenceDiscriminatorType=\' + #p0")
List<ReferenceObjectBinding> findReferenceObjectBindingsByReferenceDiscriminatorType(String referenceObjectReferenceDiscriminatorType)
                                                                                     throws RiceIllegalArgumentException
```
    Retrieves list of ReferenceObjectBinding objects for the given ref obj discriminator type
    
    Parameters:
    referenceObjectReferenceDiscriminatorType - reference object type
    
    Returns:
    list of ReferenceObjectBinding objects for the given discriminator type
    
    Throws:
    
    RiceIllegalArgumentException - if the given referenceObjectReferenceDiscriminatorType is blank or invalid
  - findReferenceObjectBindingsByKrmsDiscriminatorType
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
           key="\'referenceObjectKrmsDiscriminatorType=\' + #p0")
List<ReferenceObjectBinding> findReferenceObjectBindingsByKrmsDiscriminatorType(String referenceObjectKrmsDiscriminatorType)
                                                                                throws RiceIllegalArgumentException
```
    Retrieves list of ReferenceObjectBinding objects for the given krms obj discriminator type
    
    Parameters:
    referenceObjectKrmsDiscriminatorType - reference object type
    
    Returns:
    list of ReferenceObjectBinding objects for the given discriminator type
    
    Throws:
    
    RiceIllegalArgumentException - if the given referenceObjectKrmsDiscriminatorType is blank or invalid
  - findReferenceObjectBindingsByReferenceObject
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
           key="\'referenceObjectReferenceDiscriminatorType=\' + #p0 + \'|\' + \'referenceObjectId=\' + #p1")
List<ReferenceObjectBinding> findReferenceObjectBindingsByReferenceObject(String referenceObjectReferenceDiscriminatorType,
                                                                                  String referenceObjectId)
                                                                          throws RiceIllegalArgumentException
```
    Retrieves list of ReferenceObjectBinding objects for the given obj discriminator type and reference object id
    
    Parameters:
    referenceObjectReferenceDiscriminatorType - reference object type
    referenceObjectId - reference object id
    
    Returns:
    list of ReferenceObjectBinding objects for the given discriminator type
    
    Throws:
    
    RiceIllegalArgumentException - if the given referenceObjectKrmsDiscriminatorType or id is blank or invalid
  - findReferenceObjectBindingsByReferenceObjectIds
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
           key="\'referenceObjectReferenceDiscriminatorType=\' + #p0 + \'|\' + \'referenceObjectIds=\' + #p1")
List<ReferenceObjectBinding> findReferenceObjectBindingsByReferenceObjectIds(String referenceObjectReferenceDiscriminatorType,
                                                                                     List<String> referenceObjectIds)
                                                                             throws RiceIllegalArgumentException
```
    Retrieves list of ReferenceObjectBinding objects for the given obj discriminator type and reference object ids
    
    Parameters:
    referenceObjectReferenceDiscriminatorType - reference object type
    referenceObjectIds - reference object ids
    
    Returns:
    list of ReferenceObjectBinding objects for the given discriminator type
    
    Throws:
    
    RiceIllegalArgumentException - if the given referenceObjectKrmsDiscriminatorType or id list is blank or invalid
  - findReferenceObjectBindingsByKrmsObject
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
           key="\'krmsObjectId=\' + #p0")
List<ReferenceObjectBinding> findReferenceObjectBindingsByKrmsObject(String krmsObjectId)
                                                                     throws RiceIllegalArgumentException
```
    Retrieves list of ReferenceObjectBinding objects for the given KRMS obj id.
    
    Parameters:
    krmsObjectId - identifier of the KRMS obj
    
    Returns:
    list of ReferenceObjectBinding objects for the given KRMS obj
    
    Throws:
    
    RiceIllegalArgumentException - if the given krmsObjectId is blank or invalid
  - updateReferenceObjectBinding
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
            allEntries=true)
void updateReferenceObjectBinding(ReferenceObjectBinding referenceObjectBindingDefinition)
                                  throws RiceIllegalArgumentException
```
    Update the ReferenceObjectBinding object specified by the identifier in the given DTO
    
    Parameters:
    referenceObjectBindingDefinition - DTO with updated info and id of the object to be updated
    
    Throws:
    
    RiceIllegalArgumentException - if the given referenceObjectBindingDefinition is null or invalid
  - deleteReferenceObjectBinding
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType",
            allEntries=true)
void deleteReferenceObjectBinding(String id)
                                  throws RiceIllegalArgumentException
```
    Delete the specified ReferenceObjectBinding object
    
    Parameters:
    id - identifier of the object to be deleted
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - findReferenceObjectBindingIds
```
List<String> findReferenceObjectBindingIds(QueryByCriteria queryByCriteria)
                                           throws RiceIllegalArgumentException
```
    Query for ReferenceObjectBinding ids based on the given search criteria which is a Map of ReferenceObjectBinding field names to values.
    
    This method returns it's results as a List of ReferenceObjectBinding ids that match the given search criteria.
    
    Parameters:
    queryByCriteria - the criteria. Cannot be null.
    
    Returns:
    a list of ids matching the given criteria properties. An empty list is returned if an invalid or non-existent criteria is supplied.
    
    Throws:
    
    RiceIllegalArgumentException - if the queryByCriteria is null
  - createAgenda
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition","http://rice.kuali.org/krms/v2_0/AgendaType","http://rice.kuali.org/krms/v2_0/AgendaItemType","http://rice.kuali.org/krms/v2_0/ContextDefinitionType"},
            allEntries=true)
AgendaDefinition createAgenda(AgendaDefinition agendaDefinition)
                              throws RiceIllegalArgumentException
```
    Create Agenda and an empty first item
    
    Parameters:
    agendaDefinition - data for the new Agenda to be created
    
    Returns:
    newly created Agenda
    
    Throws:
    
    RiceIllegalArgumentException - if the given agendaDefinition is null or invalid
  - findCreateAgenda
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition","http://rice.kuali.org/krms/v2_0/AgendaType","http://rice.kuali.org/krms/v2_0/AgendaItemType","http://rice.kuali.org/krms/v2_0/ContextDefinitionType"},
            allEntries=true)
AgendaDefinition findCreateAgenda(AgendaDefinition agendaDefinition)
                                  throws RiceIllegalArgumentException
```
    Create Agenda if not found by contextId and name
    
    Parameters:
    agendaDefinition - data for the new Agenda to be created
    
    Returns:
    newly created or found Agenda
    
    Throws:
    
    RiceIllegalArgumentException - if the given agendaDefinition is null or invalid
  - getAgenda
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaType",
           key="\'id=\' + #p0")
AgendaDefinition getAgenda(String id)
                           throws RiceIllegalArgumentException
```
    Retrieve Agenda for the specified id
    
    Parameters:
    id - identifier for the Agenda
    
    Returns:
    specified Agenda
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - getAgendaByNameAndContextId
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaType",
           key="\'name=\' + #p0 + \'|\' + \'contextId=\' + #p1")
AgendaDefinition getAgendaByNameAndContextId(String name,
                                                     String contextId)
```
    Retrieves an Agenda from the repository based on the provided agenda name and context id.
    
    Parameters:
    name - the name of the Agenda to retrieve.
    contextId - the id of the context that the agenda belongs to.
    
    Returns:
    an AgendaDefinition identified by the given name and namespace. A null reference is returned if an invalid or non-existent name and namespace combination is supplied.
  - getAgendasByType
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaType",
           key="\'typeId=\' + #p0")
List<AgendaDefinition> getAgendasByType(String typeId)
                                        throws RiceIllegalArgumentException
```
    Retrieve Agendas of the specified type
    
    Parameters:
    typeId - type of the Agenda
    
    Returns:
    list of Agendas of the specified type
    
    Throws:
    
    RiceIllegalArgumentException - if the given typeId is null or invalid
  - getAgendasByContext
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaType",
           key="\'contextId=\' + #p0")
List<AgendaDefinition> getAgendasByContext(String contextId)
                                           throws RiceIllegalArgumentException
```
    Retrieve Agendas associated with the specified context
    
    Parameters:
    contextId - context of interest
    
    Returns:
    list of Agendas associated with the context
    
    Throws:
    
    RiceIllegalArgumentException - if the given contextId is null or invalid
  - getAgendasByTypeAndContext
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaType",
           key="\'typeId=\' + #p0 + \'|\' + \'contextId=\' + #p1")
List<AgendaDefinition> getAgendasByTypeAndContext(String typeId,
                                                          String contextId)
                                                  throws RiceIllegalArgumentException
```
    Retrieve Agendas of the specified type and context
    
    Parameters:
    typeId - type of the Agenda
    contextId - context of interest
    
    Returns:
    list of Agendas associated with the specified type and context
    
    Throws:
    
    RiceIllegalArgumentException - if the given typeId or contextId null or invalid
  - updateAgenda
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition","http://rice.kuali.org/krms/v2_0/AgendaType","http://rice.kuali.org/krms/v2_0/AgendaItemType","http://rice.kuali.org/krms/v2_0/ContextDefinitionType"},
            allEntries=true)
void updateAgenda(AgendaDefinition agendaDefinition)
                  throws RiceIllegalArgumentException
```
    Update the Agenda specified by the identifier in the input DTO
    
    Parameters:
    agendaDefinition - DTO with updated info and identifier of the object to be updated
    
    Throws:
    
    RiceIllegalArgumentException - if the given agendaDefinition is null or invalid
  - deleteAgenda
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition","http://rice.kuali.org/krms/v2_0/AgendaType","http://rice.kuali.org/krms/v2_0/AgendaItemType","http://rice.kuali.org/krms/v2_0/ContextDefinitionType"},
            allEntries=true)
void deleteAgenda(String id)
                  throws RiceIllegalArgumentException
```
    Delete the specified Agenda
    
    Parameters:
    id - identifier of the object to be deleted
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - createAgendaItem
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition","http://rice.kuali.org/krms/v2_0/AgendaType","http://rice.kuali.org/krms/v2_0/AgendaItemType","http://rice.kuali.org/krms/v2_0/ContextDefinitionType"},
            allEntries=true)
AgendaItemDefinition createAgendaItem(AgendaItemDefinition agendaItemDefinition)
                                      throws RiceIllegalArgumentException
```
    Create AgendaItem
    
    Parameters:
    agendaItemDefinition - data for the new AgendaItem to be created
    
    Returns:
    newly created AgendaItem
    
    Throws:
    
    RiceIllegalArgumentException - if the given agendaItemDefinition is null or invalid
  - getAgendaItem
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaItemType",
           key="\'id=\' + #p0")
AgendaItemDefinition getAgendaItem(String id)
                                   throws RiceIllegalArgumentException
```
    Retrieve AgendaItem by the specified identifier
    
    Parameters:
    id - identifier of the AgendaItem
    
    Returns:
    AgendaItem specified by the identifier
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - getAgendaItemsByType
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaItemType",
           key="\'typeId=\' + #p0")
List<AgendaItemDefinition> getAgendaItemsByType(String typeId)
                                                throws RiceIllegalArgumentException
```
    Retrieve AgendaItems by specified type
    
    Parameters:
    typeId - type of the AgendaItems
    
    Returns:
    list of AgendaItems of the specified type
    
    Throws:
    
    RiceIllegalArgumentException - if the given typeId is null or invalid
  - getAgendaItemsByContext
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaItemType",
           key="\'contextId=\' + #p0")
List<AgendaItemDefinition> getAgendaItemsByContext(String contextId)
                                                   throws RiceIllegalArgumentException
```
    Retrieve AgendaItems associated with a context
    
    Parameters:
    contextId - context identifier
    
    Returns:
    list of AgendaItems associated with a context
    
    Throws:
    
    RiceIllegalArgumentException - if the given contextId is null or invalid
  - getAgendaItemsByTypeAndContext
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaItemType",
           key="\'typeId=\' + #p0 + \'|\' + \'contextId=\' + #p1")
List<AgendaItemDefinition> getAgendaItemsByTypeAndContext(String typeId,
                                                                  String contextId)
                                                          throws RiceIllegalArgumentException
```
    Retrieve AgendaItems by type and context
    
    Parameters:
    typeId - type of the Agendas
    contextId - context with which the Agendas are associated
    
    Returns:
    list of AgendaItems of the specified type and context
    
    Throws:
    
    RiceIllegalArgumentException - if the given typeId or contextId null or invalid
  - updateAgendaItem
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition","http://rice.kuali.org/krms/v2_0/AgendaType","http://rice.kuali.org/krms/v2_0/AgendaItemType","http://rice.kuali.org/krms/v2_0/ContextDefinitionType"},
            allEntries=true,
            beforeInvocation=true)
void updateAgendaItem(AgendaItemDefinition agendaItemDefinition)
                      throws RiceIllegalArgumentException
```
    Update an AgendaItem
    
    Parameters:
    agendaItemDefinition - updated data for the AgendaItem, with id of the object to be updated
    
    Throws:
    
    RiceIllegalArgumentException - if the given agendaItemDefinition is null or invalid
  - deleteAgendaItem
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition","http://rice.kuali.org/krms/v2_0/AgendaType","http://rice.kuali.org/krms/v2_0/AgendaItemType","http://rice.kuali.org/krms/v2_0/ContextDefinitionType"},
            allEntries=true)
void deleteAgendaItem(String id)
                      throws RiceIllegalArgumentException
```
    Delete the specified AgendaItem
    
    Parameters:
    id - identifier of the AgendaItem to be deleted
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - createRule
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/RuleType","http://rice.kuali.org/krms/v2_0/PropositionType","http://rice.kuali.org/krms/v2_0/ActionType","http://rice.kuali.org/krms/v2_0/AgendaItemType"},
            allEntries=true)
RuleDefinition createRule(RuleDefinition ruleDefinition)
                          throws RiceIllegalArgumentException
```
    Create Rule
    
    Parameters:
    ruleDefinition - data for the new Rule to be created
    
    Returns:
    newly created Rule
    
    Throws:
    
    RiceIllegalArgumentException - if the given ruleDefinition is null or invalid
  - getRule
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/RuleType",
           key="\'ruleId=\' + #p0")
RuleDefinition getRule(String ruleId)
```
    Retrieves the rule for the given ruleId. The rule includes the propositions which define the condition that is to be evaluated on the rule. It also defines a collection of actions which will be invoked if the rule succeeds.
    
    Parameters:
    ruleId - the id of the rule to retrieve
    
    Returns:
    the rule definition, or null if no rule could be located for the given ruleId
    
    Throws:
    
    IllegalArgumentException - if the given ruleId is null
  - getRuleByNameAndNamespace
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/RuleType",
           key="\'name=\' + #p0 + \'|\' + \'namespace=\' + #p1")
RuleDefinition getRuleByNameAndNamespace(String name,
                                                 String namespace)
```
    Retrieves an Rule from the repository based on the provided rule name and namespace.
    
    Parameters:
    name - the name of the Rule to retrieve.
    namespace - the namespace that the rule is under.
    
    Returns:
    an RuleDefinition identified by the given name and namespace. A null reference is returned if an invalid or non-existent name and namespace combination is supplied.
    
    Throws:
    
    IllegalArgumentException - if the either the name or the namespace is null or blank.
  - getRules
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/RuleType",
           key="\'ruleIds=\' + T(org.kuali.rice.core.api.cache.CacheKeyUtils).key(#p0)")
List<RuleDefinition> getRules(List<String> ruleIds)
```
    Retrieves all of the rules for the given list of ruleIds. The rule includes the propositions which define the condition that is to be evaluated on the rule. It also defines a collection of actions which will be invoked if the rule succeeds.
    
    The list which is returned from this operation may not be the same size as the list which is passed to this method. If a rule doesn't exist for a given rule id then no result for that id will be returned in the list. As a result of this, the returned list can be empty, but it will never be null.
    
    Parameters:
    ruleIds - the list of rule ids for which to retrieve the rules
    
    Returns:
    the list of rules for the given ids, this list will only contain rules for the ids that were resolved successfully, it will never return null but could return an empty list if no rules could be loaded for the given set of ids
    
    Throws:
    
    IllegalArgumentException - if the given list of ruleIds is null
  - updateRule
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/RuleType","http://rice.kuali.org/krms/v2_0/PropositionType","http://rice.kuali.org/krms/v2_0/ActionType","http://rice.kuali.org/krms/v2_0/AgendaItemType"},
            allEntries=true)
void updateRule(RuleDefinition ruleDefinition)
                throws RiceIllegalArgumentException
```
    Update the Rule specified by the identifier in the DTO
    
    Parameters:
    ruleDefinition - updated Rule information, object specified by the id
    
    Throws:
    
    RiceIllegalArgumentException - if the given ruleDefinition is null or invalid
  - deleteRule
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/RuleType","http://rice.kuali.org/krms/v2_0/PropositionType","http://rice.kuali.org/krms/v2_0/ActionType","http://rice.kuali.org/krms/v2_0/AgendaItemType"},
            allEntries=true)
void deleteRule(String id)
                throws RiceIllegalArgumentException
```
    Delete the specified Rule
    
    Parameters:
    id - identifier of the Rule to be deleted
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - createAction
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/ActionType","http://rice.kuali.org/krms/v2_0/RuleType"},
            allEntries=true)
ActionDefinition createAction(ActionDefinition actionDefinition)
                              throws RiceIllegalArgumentException
```
    Create Action
    
    Parameters:
    actionDefinition - data for the new Action to be created
    
    Returns:
    newly created Action
    
    Throws:
    
    RiceIllegalArgumentException - if the given actionDefinition is null or invalid
  - getAction
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ActionType",
           key="\'actionId=\' + #p0")
ActionDefinition getAction(String actionId)
                           throws RiceIllegalArgumentException
```
    Retrieves the action for the given actionId. The action includes the propositions which define the condition that is to be evaluated on the action. It also defines a collection of actions which will be invoked if the action succeeds.
    
    Parameters:
    actionId - the id of the action to retrieve
    
    Returns:
    the action definition, or null if no action could be located for the given actionId
    
    Throws:
    
    IllegalArgumentException - if the given actionId is null
    
    RiceIllegalArgumentException
  - getActions
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ActionType",
           key="\'actionIds=\' + T(org.kuali.rice.core.api.cache.CacheKeyUtils).key(#p0)")
List<ActionDefinition> getActions(List<String> actionIds)
                                  throws RiceIllegalArgumentException
```
    Retrieves all of the actions for the given list of actionIds.
    
    The list which is returned from this operation may not be the same size as the list which is passed to this method. If a action doesn't exist for a given action id then no result for that id will be returned in the list. As a result of this, the returned list can be empty, but it will never be null.
    
    Parameters:
    actionIds - the list of action ids for which to retrieve the actions
    
    Returns:
    the list of actions for the given ids, this list will only contain actions for the ids that were resolved successfully, it will never return null but could return an empty list if no actions could be loaded for the given set of ids
    
    Throws:
    
    IllegalArgumentException - if the given list of actionIds is null
    
    RiceIllegalArgumentException
  - updateAction
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/ActionType","http://rice.kuali.org/krms/v2_0/RuleType"},
            allEntries=true)
void updateAction(ActionDefinition actionDefinition)
                  throws RiceIllegalArgumentException
```
    Update the Action specified by the identifier in the DTO
    
    Parameters:
    actionDefinition - updated Action information, object specified by the id
    
    Throws:
    
    RiceIllegalArgumentException - if the given actionDefinition is null or invalid
  - deleteAction
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/ActionType","http://rice.kuali.org/krms/v2_0/RuleType"},
            allEntries=true)
void deleteAction(String id)
                  throws RiceIllegalArgumentException
```
    Delete the specified Action
    
    Parameters:
    id - identifier of the Action to be deleted
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - createProposition
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/PropositionType","http://rice.kuali.org/krms/v2_0/RuleType"},
            allEntries=true)
PropositionDefinition createProposition(PropositionDefinition propositionDefinition)
                                        throws RiceIllegalArgumentException
```
    Create a Proposition
    
    Parameters:
    propositionDefinition - data for the new Proposition to be created
    
    Returns:
    newly created Proposition
    
    Throws:
    
    RiceIllegalArgumentException - if the given propositionDefinition is null or invalid
  - getProposition
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/PropositionType",
           key="\'id=\' + #p0")
PropositionDefinition getProposition(String id)
                                     throws RiceIllegalArgumentException
```
    Retrieve Proposition specified by the identifier
    
    Parameters:
    id - identifier of the Proposition to be retrieved
    
    Returns:
    specified Proposition
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - getPropositionsByType
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/PropositionType",
           key="\'typeId=\' + #p0")
Set<PropositionDefinition> getPropositionsByType(String typeId)
                                                 throws RiceIllegalArgumentException
```
    Retrieve Propositions of the specified type
    
    Parameters:
    typeId - type of the Propositions to be retrieved
    
    Returns:
    list of Propositions of the specified type
    
    Throws:
    
    RiceIllegalArgumentException - if the given typeId is null or invalid
  - getPropositionsByRule
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/PropositionType",
           key="\'ruleId=\' + #p0")
Set<PropositionDefinition> getPropositionsByRule(String ruleId)
                                                 throws RiceIllegalArgumentException
```
    Retrieve Propositions associated with the specified Rule
    
    Parameters:
    ruleId - identifier of the Rule to which the Propositions are associated with
    
    Returns:
    list of Propositions associated with the Rule
    
    Throws:
    
    RiceIllegalArgumentException - if the given ruleId is null or invalid
  - updateProposition
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/PropositionType","http://rice.kuali.org/krms/v2_0/RuleType"},
            allEntries=true)
void updateProposition(PropositionDefinition propositionDefinition)
                       throws RiceIllegalArgumentException
```
    Update the Proposition
    
    Parameters:
    propositionDefinition - updated data for the Proposition, id specifies the object to be updated
    
    Throws:
    
    RiceIllegalArgumentException - if the given propositionDefinition is null or invalid
  - deleteProposition
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/PropositionType","http://rice.kuali.org/krms/v2_0/RuleType"},
            allEntries=true)
void deleteProposition(String id)
                       throws RiceIllegalArgumentException
```
    Delete the Proposition
    
    Parameters:
    id - identifier of the Proposition to be deleted
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - createNaturalLanguageUsage
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/NaturalLanguageUsageType","http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType"},
            allEntries=true)
NaturalLanguageUsage createNaturalLanguageUsage(NaturalLanguageUsage naturalLanguageUsage)
                                                throws RiceIllegalArgumentException
```
    Create NaturalLanguageUsage
    
    Parameters:
    naturalLanguageUsage - data for the new NaturalLanguageUsage to be created
    
    Returns:
    newly created NaturalLanguageUsage
    
    Throws:
    
    RiceIllegalArgumentException - if the given naturalLanguageUsage is null or invalid
  - getNaturalLanguageUsage
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageUsageType",
           key="\'id=\' + #p0")
NaturalLanguageUsage getNaturalLanguageUsage(String id)
                                             throws RiceIllegalArgumentException
```
    Retrieve NaturalLanguageUsage specified by the identifier
    
    Parameters:
    id - identifier of the NaturalLanguageUsage to be retrieved
    
    Returns:
    NaturalLanguageUsage specified by the identifier
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - getNaturalLanguageUsageByNameAndNamespace
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageUsageType",
           key="\'name=\' + #p0 + \'|\' + \'namespace=\' + #p1")
NaturalLanguageUsage getNaturalLanguageUsageByNameAndNamespace(String name,
                                                                       String namespace)
                                                               throws RiceIllegalArgumentException
```
    Retrieve NaturalLanguageUsage specified by name and namespace
    
    Parameters:
    name - the name of the natural language usage to retrieve.
    namespace - the namespace that the natural language usage is under.
    
    Returns:
    an NaturalLanguageUsage identified by the given name and namespace. A null reference is returned if an invalid or non-existent name and namespace combination is supplied.
    
    Throws:
    
    RiceIllegalArgumentException - if the either the name or the namespace is null or blank.
  - updateNaturalLanguageUsage
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/NaturalLanguageUsageType","http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType"},
            allEntries=true)
void updateNaturalLanguageUsage(NaturalLanguageUsage naturalLanguageUsage)
                                throws RiceIllegalArgumentException
```
    Update NaturalLanguageUsage
    
    Parameters:
    naturalLanguageUsage - updated data for the NaturalLanguageUsage object specified by the id
    
    Throws:
    
    RiceIllegalArgumentException - if the given naturalLanguageUsage is null or invalid
  - deleteNaturalLanguageUsage
```
@CacheEvict(value={"http://rice.kuali.org/krms/v2_0/NaturalLanguageUsageType","http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType"},
            allEntries=true)
void deleteNaturalLanguageUsage(String naturalLanguageUsageId)
                                throws RiceIllegalArgumentException
```
    Delete NaturalLanguageUsage
    
    Parameters:
    naturalLanguageUsageId - identifier of the NaturalLanguageUsage to be deleted
    
    Throws:
    
    RiceIllegalArgumentException - if the given naturalLanguageUsageId is null or invalid
  - getNaturalLanguageUsagesByNamespace
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageUsageType",
           key="\'namespace=\' + #p0")
List<NaturalLanguageUsage> getNaturalLanguageUsagesByNamespace(String namespace)
                                                               throws RiceIllegalArgumentException
```
    Translates and retrieves a NaturalLanguage for a given KRMS object (e.g, proposition or agenda), NaturalLanguage usage type (context) and language into natural language
    
    Parameters:
    namespace - namespace to search on.
    
    Returns:
    list of NaturalLanguageUsages in a particular namespace
    
    Throws:
    
    RiceIllegalArgumentException
  - createContext
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/ContextDefinitionType",
            allEntries=true)
ContextDefinition createContext(ContextDefinition contextDefinition)
                                throws RiceIllegalArgumentException
```
    Create Context
    
    Parameters:
    contextDefinition - data for the new Context to be created
    
    Returns:
    newly created Context
    
    Throws:
    
    RiceIllegalArgumentException - if the given contextDefinition is null or invalid or already in use.
  - findCreateContext
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/ContextDefinitionType",
            allEntries=true)
ContextDefinition findCreateContext(ContextDefinition contextDefinition)
                                    throws RiceIllegalArgumentException
```
    find Create Context Searches for an existing context with the same name and namespace and returns it otherwise it creates the context.
    
    Parameters:
    contextDefinition - data for the new Context to be created
    
    Returns:
    newly created Context
    
    Throws:
    
    RiceIllegalArgumentException - if the given contextDefinition is null or invalid
  - updateContext
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/ContextDefinitionType",
            allEntries=true)
void updateContext(ContextDefinition contextDefinition)
                   throws RiceIllegalArgumentException
```
    Update the Context specified by the identifier in the input DTO
    
    Parameters:
    contextDefinition - DTO with updated info and identifier of the object to be updated
    
    Throws:
    
    RiceIllegalArgumentException - if the given contextDefinition is null or invalid
  - deleteContext
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/ContextDefinitionType",
            allEntries=true)
void deleteContext(String id)
                   throws RiceIllegalArgumentException
```
    Delete the specified Context
    
    Parameters:
    id - identifier of the object to be deleted
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - getContext
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ContextDefinitionType",
           key="\'id=\' + #p0")
ContextDefinition getContext(String id)
                             throws RiceIllegalArgumentException
```
    Retrieve Context for the specified id
    
    Parameters:
    id - identifier for the Context
    
    Returns:
    specified Context
    
    Throws:
    
    RiceIllegalArgumentException - if the given id is null or invalid
  - getContextByNameAndNamespace
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/ContextDefinitionType",
           key="\'name=\' + #p0 + \'|\' + \'namespace=\' + #p1")
ContextDefinition getContextByNameAndNamespace(String name,
                                                       String namespace)
                                               throws RiceIllegalArgumentException
```
    Retrieves an Context from the repository based on the provided context name and namespace.
    
    Parameters:
    name - the name of the Context to retrieve.
    namespace - the namespace that the context is under.
    
    Returns:
    an ContextDefinition identified by the given name and namespace. A null reference is returned if an invalid or non-existent name and namespace combination is supplied.
    
    Throws:
    
    RiceIllegalArgumentException - if the either the name or the namespace is null or blank.
  - createNaturalLanguageTemplate
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
            allEntries=true)
NaturalLanguageTemplate createNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate)
                                                      throws RiceIllegalArgumentException
```
    This will create a NaturalLanguageTemplate exactly like the parameter passed in except the id will be assigned and create date/user will be set.
    
    Parameters:
    naturalLanguageTemplate - The NaturalLanguageTemplate to create.
    
    Returns:
    a NaturalLanguageTemplate exactly like the parameter passed in.
    
    Throws:
    
    RiceIllegalArgumentException - if the NaturalLanguageTemplate is null.
    
    IllegalStateException - if the NaturalLanguageTemplate already exists in the system.
  - getNaturalLanguageTemplate
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
           key="\'naturalLanguageTemplateId=\' + #p0")
NaturalLanguageTemplate getNaturalLanguageTemplate(String naturalLanguageTemplateId)
                                                   throws RiceIllegalArgumentException
```
    Retrieves a NaturalLanguageTemplate from the repository based on the given id.
    
    Parameters:
    naturalLanguageTemplateId - to retrieve.
    
    Returns:
    a NaturalLanguageTemplate identified by the given id.
    
    Throws:
    
    IllegalArgumentException - if the given actionId is null *
    
    RiceIllegalArgumentException
  - updateNaturalLanguageTemplate
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
            allEntries=true)
void updateNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate)
                                   throws RiceIllegalArgumentException
```
    This will update an existing NaturalLanguageTemplate.
    
    Parameters:
    naturalLanguageTemplate - The NaturalLanguageTemplate to update.
    
    Throws:
    
    RiceIllegalArgumentException - if the NaturalLanguageTemplate is null. exists in the system.
  - deleteNaturalLanguageTemplate
```
@CacheEvict(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
            allEntries=true)
void deleteNaturalLanguageTemplate(String naturalLanguageTemplateId)
                                   throws RiceIllegalArgumentException
```
    Delete the NaturalLanguageTemplate with the given id.
    
    Parameters:
    naturalLanguageTemplateId - to delete.
    
    Throws:
    
    RiceIllegalArgumentException - if the NaturalLanguageTemplate is null.
  - findNaturalLanguageTemplatesByLanguageCode
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
           key="\'languageCode=\' + #p0")
List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByLanguageCode(String languageCode)
                                                                         throws RiceIllegalArgumentException
```
    Finds all the natural language templates for a particular language
    
    Parameters:
    languageCode - language on which to search
    
    Returns:
    list of templates for that language
    
    Throws:
    
    RiceIllegalArgumentException
  - findNaturalLanguageTemplateByLanguageCodeTypeIdAndNluId
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
           key="\'languageCode=\' + #p0 + \'|\' + \'typeId=\' + #p1 + \'|\' + \'naturalLanguageUsageId=\' + #p2")
NaturalLanguageTemplate findNaturalLanguageTemplateByLanguageCodeTypeIdAndNluId(String languageCode,
                                                                                        String typeId,
                                                                                        String naturalLanguageUsageId)
                                                                                throws RiceIllegalArgumentException
```
    Throws:
    
    RiceIllegalArgumentException
  - findNaturalLanguageTemplatesByNaturalLanguageUsage
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
           key="\'naturalLanguageUsageId=\' + #p0")
List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByNaturalLanguageUsage(String naturalLanguageUsageId)
                                                                                 throws RiceIllegalArgumentException
```
    Find all the natural language templates for a particular usage
    
    Parameters:
    naturalLanguageUsageId - the usage on which to search
    
    Returns:
    list of templates that match the usage
    
    Throws:
    
    RiceIllegalArgumentException
  - findNaturalLanguageTemplatesByType
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
           key="\'typeId=\' + #p0")
List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByType(String typeId)
                                                                 throws RiceIllegalArgumentException
```
    Find all the natural language templates of a particular type Template types are keys that identify the message that is to be expressed in different languages and in different usage scenarios
    
    Parameters:
    typeId - on which to search
    
    Returns:
    list of templates matching that type
    
    Throws:
    
    RiceIllegalArgumentException
  - findNaturalLanguageTemplatesByTemplate
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType",
           key="\'template=\' + #p0")
List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByTemplate(String template)
                                                                     throws RiceIllegalArgumentException
```
    Find the natural language template using the actual text of the template.
    
    Parameters:
    template - text to match exactly
    
    Returns:
    list of matching templates
    
    Throws:
    
    RiceIllegalArgumentException
  - translateNaturalLanguageForObject
```
String translateNaturalLanguageForObject(String naturalLanguageUsageId,
                                       String typeId,
                                       String krmsObjectId,
                                       String languageCode)
                                         throws RiceIllegalArgumentException
```
    Translates and retrieves a NaturalLanguage for a given KRMS object (e.g, proposition or agenda), NaturalLanguage usage type (context) and language into natural language TODO: Add appropriate caching annotation
    
    Specified by:
    
    translateNaturalLanguageForObject in interface TranslateBusinessMethods
    
    Parameters:
    naturalLanguageUsageId - Natural language usage information
    typeId - KRMS object type id (for example, could refer to agenda or proposition)
    krmsObjectId - KRMS object identifier
    languageCode - desired
    
    Returns:
    natural language corresponding to the NaturalLanguage usage, KRMS object id, KRMS object type and desired language
    
    Throws:
    
    RiceIllegalArgumentException - if the given naturalLanguageUsageId, typeId, krmsObjectId or language is null or invalid
  - translateNaturalLanguageForObjects
```
List<NaturalLanguage> translateNaturalLanguageForObjects(String naturalLanguageUsageId,
                                                       String typeId,
                                                       List<String> krmsObjectIds,
                                                       String languageCode)
                                                         throws RiceIllegalArgumentException
```
    Translates and retrieves a NaturalLanguage for a list of KRMS objects (e.g, propositions or agendas), NaturalLanguage usage type (context) and language into natural language
    
    Parameters:
    naturalLanguageUsageId - Natural language usage information
    typeId - KRMS object type id (for example, could refer to agenda or proposition)
    krmsObjectIds - KRMS object identifier
    languageCode - desired
    
    Returns:
    natural language corresponding to the NaturalLanguage usage, KRMS object id, KRMS object type and desired language
    
    Throws:
    
    RiceIllegalArgumentException - if the given naturalLanguageUsageId, typeId, krmsObjectId or language is null or invalid
  - translateNaturalLanguageForProposition
```
String translateNaturalLanguageForProposition(String naturalLanguageUsageId,
                                            PropositionDefinition propositionDefinintion,
                                            String languageCode)
                                              throws RiceIllegalArgumentException
```
    Retrieve all the NaturalLanguageUsages
    
    Specified by:
    
    translateNaturalLanguageForProposition in interface TranslateBusinessMethods
    
    Returns:
    list of NaturalLanguageUsages
    
    Throws:
    
    RiceIllegalArgumentException
  - translateNaturalLanguageTreeForProposition
```
NaturalLanguageTree translateNaturalLanguageTreeForProposition(String naturalLanguageUsageId,
                                                             PropositionDefinition propositionDefinintion,
                                                             String languageCode)
                                                               throws RiceIllegalArgumentException
```
    Translates NaturalLanguage for a given proposition, returning a tree of the NaturalLanguage. This method is used to "preview" the proposition in a tree structure before saving.
    
    Specified by:
    
    translateNaturalLanguageTreeForProposition in interface TranslateBusinessMethods
    
    Parameters:
    naturalLanguageUsageId - Natural language usage information
    propositionDefinintion - proposition to be translated
    languageCode - desired
    
    Returns:
    natural language tree corresponding to the NaturalLanguage usage, proposition and desired language
    
    Throws:
    
    RiceIllegalArgumentException - if the given naturalLanguageUsageId, proposition, or language is null or invalid
  - findContextIds
```
List<String> findContextIds(QueryByCriteria queryByCriteria)
                            throws RiceIllegalArgumentException
```
    Query for Context ids based on the given search criteria which is a Map of Context field names to values.
    
    This method returns it's results as a List of Context ids that match the given search criteria.
    
    Parameters:
    queryByCriteria - the criteria. Cannot be null.
    
    Returns:
    a list of ids matching the given criteria properties. An empty list is returned if an invalid or non-existent criteria is supplied.
    
    Throws:
    
    RiceIllegalArgumentException - if the queryByCriteria is null
  - findAgendaIds
```
List<String> findAgendaIds(QueryByCriteria queryByCriteria)
                           throws RiceIllegalArgumentException
```
    Query for Agenda ids based on the given search criteria which is a Map of Agenda field names to values.
    
    This method returns it's results as a List of Agenda ids that match the given search criteria.
    
    Parameters:
    queryByCriteria - the criteria. Cannot be null.
    
    Returns:
    a list of ids matching the given criteria properties. An empty list is returned if an invalid or non-existent criteria is supplied.
    
    Throws:
    
    RiceIllegalArgumentException - if the queryByCriteria is null
  - findRuleIds
```
List<String> findRuleIds(QueryByCriteria queryByCriteria)
                         throws RiceIllegalArgumentException
```
    Query for Rule ids based on the given search criteria which is a Map of Rule field names to values.
    
    This method returns it's results as a List of Rule ids that match the given search criteria.
    
    Parameters:
    queryByCriteria - the criteria. Cannot be null.
    
    Returns:
    a list of ids matching the given criteria properties. An empty list is returned if an invalid or non-existent criteria is supplied.
    
    Throws:
    
    RiceIllegalArgumentException - if the queryByCriteria is null
  - findPropositionIds
```
List<String> findPropositionIds(QueryByCriteria queryByCriteria)
                                throws RiceIllegalArgumentException
```
    Query for Proposition ids based on the given search criteria which is a Map of Proposition field names to values.
    
    This method returns it's results as a List of Proposition ids that match the given search criteria.
    
    Parameters:
    queryByCriteria - the criteria. Cannot be null.
    
    Returns:
    a list of ids matching the given criteria properties. An empty list is returned if an invalid or non-existent criteria is supplied.
    
    Throws:
    
    RiceIllegalArgumentException - if the queryByCriteria is null
  - findActionIds
```
List<String> findActionIds(QueryByCriteria queryByCriteria)
                           throws RiceIllegalArgumentException
```
    Query for Action ids based on the given search criteria which is a Map of Action field names to values.
    
    This method returns it's results as a List of Action ids that match the given search criteria.
    
    Parameters:
    queryByCriteria - the criteria. Cannot be null.
    
    Returns:
    a list of ids matching the given criteria properties. An empty list is returned if an invalid or non-existent criteria is supplied.
    
    Throws:
    
    RiceIllegalArgumentException - if the queryByCriteria is null
  - selectContext
```
ContextDefinition selectContext(ContextSelectionCriteria contextSelectionCriteria)
                                throws RiceIllegalArgumentException
```
    Locates a ContextDefinition based on the given map of context qualifiers. The requirements for valid selection criteria are implementation dependent. An IllegalArgumentException may be thrown if the implementation can't operate with the given criteria.
    
    Parameters:
    contextSelectionCriteria -
    
    Returns:
    
    Throws:
    
    RiceIllegalArgumentException - if the implementation can't handle the given ContextSelectionCriteria
    See Also:
    ContextSelectionCriteria
  - getAgendaTree
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition",
           key="\'agendaId=\' + #p0")
AgendaTreeDefinition getAgendaTree(String agendaId)
                                   throws RiceIllegalArgumentException
```
    Retrieves the agenda tree for the given agendaId. The agenda tree includes the entire agenda definition in the appropriate order and with the defined agenda branching.
    
    Parameters:
    agendaId - the id of the agenda for which to retrieve the agenda tree
    
    Returns:
    the agenda tree, or null if no agenda could be located for the given agendaId
    
    Throws:
    
    RiceIllegalArgumentException - if the given agendaId is null
  - getAgendaTrees
```
@Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition",
           key="\'agendaIds=\' + T(org.kuali.rice.core.api.cache.CacheKeyUtils).key(#p0)")
List<AgendaTreeDefinition> getAgendaTrees(List<String> agendaIds)
                                          throws RiceIllegalArgumentException
```
    Retrieves all of the agendas trees for the given list of agendaIds. The agenda tree includes the entire agenda definition in the appropriate order and with the defined agenda branching.
    The list which is returned from this operation may not be the same size as the list which is passed to this method. If an agenda doesn't exist for a given agenda id then no result for that id will be returned in the list. As a result of this, the returned list can be empty, but it will never be null.
    
    Parameters:
    agendaIds - the list of agenda ids for which to retrieve the agenda trees
    
    Returns:
    the list of agenda trees for the given ids, this list will only contain agenda trees for the ids that were resolved successfully, it will never return null but could return an empty list if no agenda trees could be loaded for the given set of ids
    
    Throws:
    
    RiceIllegalArgumentException - if the given list of agendaIds is null

Interface RuleManagementService

Method Summary

Method Detail

createReferenceObjectBinding

getReferenceObjectBinding

getReferenceObjectBindings

findReferenceObjectBindingsByReferenceDiscriminatorType

findReferenceObjectBindingsByKrmsDiscriminatorType

findReferenceObjectBindingsByReferenceObject

findReferenceObjectBindingsByReferenceObjectIds

findReferenceObjectBindingsByKrmsObject

updateReferenceObjectBinding

deleteReferenceObjectBinding

findReferenceObjectBindingIds

createAgenda

findCreateAgenda

getAgenda

getAgendaByNameAndContextId

getAgendasByType

getAgendasByContext

getAgendasByTypeAndContext

updateAgenda

deleteAgenda

createAgendaItem

getAgendaItem

getAgendaItemsByType

getAgendaItemsByContext

getAgendaItemsByTypeAndContext

updateAgendaItem

deleteAgendaItem

createRule

getRule

getRuleByNameAndNamespace

getRules

updateRule

deleteRule

createAction

getAction

getActions

updateAction

deleteAction

createProposition

getProposition

getPropositionsByType

getPropositionsByRule

updateProposition

deleteProposition

createNaturalLanguageUsage

getNaturalLanguageUsage

getNaturalLanguageUsageByNameAndNamespace

updateNaturalLanguageUsage

deleteNaturalLanguageUsage

getNaturalLanguageUsagesByNamespace

createContext

findCreateContext

updateContext

deleteContext

getContext

getContextByNameAndNamespace

createNaturalLanguageTemplate

getNaturalLanguageTemplate

updateNaturalLanguageTemplate

deleteNaturalLanguageTemplate

findNaturalLanguageTemplatesByLanguageCode

findNaturalLanguageTemplateByLanguageCodeTypeIdAndNluId

findNaturalLanguageTemplatesByNaturalLanguageUsage

findNaturalLanguageTemplatesByType

findNaturalLanguageTemplatesByTemplate

translateNaturalLanguageForObject

translateNaturalLanguageForObjects

translateNaturalLanguageForProposition

translateNaturalLanguageTreeForProposition

findContextIds

findAgendaIds

findRuleIds

findPropositionIds

findActionIds

selectContext

getAgendaTree

getAgendaTrees