Package org.kuali.rice.krms.api.repository

Interface RuleManagementService

All Superinterfaces:
TranslateBusinessMethods
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 Details

    • createReferenceObjectBinding

      @CacheEvict(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType", allEntries=true) ReferenceObjectBinding createReferenceObjectBinding(ReferenceObjectBinding referenceObjectDefinition) throws org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Create RefObject-KRMS object binding
      Parameters:
      referenceObjectDefinition - data for the new ReferenceObjectBinding to be created
      Returns:
      newly created ReferenceObjectBinding
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the given referenceObjectKrmsDiscriminatorType or id is blank or invalid

    • findReferenceObjectBindingsByKrmsObject

      @Cacheable(value="http://rice.kuali.org/krms/v2_0/ReferenceObjectBindingType", key="\'krmsObjectId=\' + #p0") List<ReferenceObjectBinding> findReferenceObjectBindingsByKrmsObject(String krmsObjectId) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete the specified ReferenceObjectBinding object
      Parameters:
      id - identifier of the object to be deleted
      Throws:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the given id is null or invalid

    • findReferenceObjectBindingIds

      List<String> findReferenceObjectBindingIds(org.kuali.rice.core.api.criteria.QueryByCriteria queryByCriteria) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Create Agenda and an empty first item
      Parameters:
      agendaDefinition - data for the new Agenda to be created
      Returns:
      newly created Agenda
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve Agenda for the specified id
      Parameters:
      id - identifier for the Agenda
      Returns:
      specified Agenda
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve Agendas of the specified type
      Parameters:
      typeId - type of the Agenda
      Returns:
      list of Agendas of the specified type
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve Agendas associated with the specified context
      Parameters:
      contextId - context of interest
      Returns:
      list of Agendas associated with the context
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete the specified Agenda
      Parameters:
      id - identifier of the object to be deleted
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Create AgendaItem
      Parameters:
      agendaItemDefinition - data for the new AgendaItem to be created
      Returns:
      newly created AgendaItem
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve AgendaItem by the specified identifier
      Parameters:
      id - identifier of the AgendaItem
      Returns:
      AgendaItem specified by the identifier
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve AgendaItems by specified type
      Parameters:
      typeId - type of the AgendaItems
      Returns:
      list of AgendaItems of the specified type
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve AgendaItems associated with a context
      Parameters:
      contextId - context identifier
      Returns:
      list of AgendaItems associated with a context
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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) void updateAgendaItem(AgendaItemDefinition agendaItemDefinition) throws org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Update an AgendaItem
      Parameters:
      agendaItemDefinition - updated data for the AgendaItem, with id of the object to be updated
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete the specified AgendaItem
      Parameters:
      id - identifier of the AgendaItem to be deleted
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Create Rule
      Parameters:
      ruleDefinition - data for the new Rule to be created
      Returns:
      newly created Rule
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Update the Rule specified by the identifier in the DTO
      Parameters:
      ruleDefinition - updated Rule information, object specified by the id
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete the specified Rule
      Parameters:
      id - identifier of the Rule to be deleted
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Create Action
      Parameters:
      actionDefinition - data for the new Action to be created
      Returns:
      newly created Action
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Update the Action specified by the identifier in the DTO
      Parameters:
      actionDefinition - updated Action information, object specified by the id
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete the specified Action
      Parameters:
      id - identifier of the Action to be deleted
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Create a Proposition
      Parameters:
      propositionDefinition - data for the new Proposition to be created
      Returns:
      newly created Proposition
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve Proposition specified by the identifier
      Parameters:
      id - identifier of the Proposition to be retrieved
      Returns:
      specified Proposition
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Update the Proposition
      Parameters:
      propositionDefinition - updated data for the Proposition, id specifies the object to be updated
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete the Proposition
      Parameters:
      id - identifier of the Proposition to be deleted
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Create NaturalLanguageUsage
      Parameters:
      naturalLanguageUsage - data for the new NaturalLanguageUsage to be created
      Returns:
      newly created NaturalLanguageUsage
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve NaturalLanguageUsage specified by the identifier
      Parameters:
      id - identifier of the NaturalLanguageUsage to be retrieved
      Returns:
      NaturalLanguageUsage specified by the identifier
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Update NaturalLanguageUsage
      Parameters:
      naturalLanguageUsage - updated data for the NaturalLanguageUsage object specified by the id
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete NaturalLanguageUsage
      Parameters:
      naturalLanguageUsageId - identifier of the NaturalLanguageUsage to be deleted
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException

    • createContext

      @CacheEvict(value="http://rice.kuali.org/krms/v2_0/ContextDefinitionType", allEntries=true) ContextDefinition createContext(ContextDefinition contextDefinition) throws org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Create Context
      Parameters:
      contextDefinition - data for the new Context to be created
      Returns:
      newly created Context
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete the specified Context
      Parameters:
      id - identifier of the object to be deleted
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve Context for the specified id
      Parameters:
      id - identifier for the Context
      Returns:
      specified Context
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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 *
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException

    • updateNaturalLanguageTemplate

      @CacheEvict(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType", allEntries=true) void updateNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate) throws org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      This will update an existing NaturalLanguageTemplate.
      Parameters:
      naturalLanguageTemplate - The NaturalLanguageTemplate to update.
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Delete the NaturalLanguageTemplate with the given id.
      Parameters:
      naturalLanguageTemplateId - to delete.
      Throws:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Throws:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException

    • findNaturalLanguageTemplatesByNaturalLanguageUsage

      @Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType", key="\'naturalLanguageUsageId=\' + #p0") List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByNaturalLanguageUsage(String naturalLanguageUsageId) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException

    • findNaturalLanguageTemplatesByType

      @Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType", key="\'typeId=\' + #p0") List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByType(String typeId) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException

    • findNaturalLanguageTemplatesByTemplate

      @Cacheable(value="http://rice.kuali.org/krms/v2_0/NaturalLanguageTemplateType", key="\'template=\' + #p0") List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByTemplate(String template) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException

    • translateNaturalLanguageForObject

      String translateNaturalLanguageForObject(String naturalLanguageUsageId, String typeId, String krmsObjectId, String languageCode) throws org.kuali.rice.core.api.exception.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
      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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the given naturalLanguageUsageId, typeId, krmsObjectId or language is null or invalid

    • translateNaturalLanguageForProposition

      String translateNaturalLanguageForProposition(String naturalLanguageUsageId, PropositionDefinition propositionDefinintion, String languageCode) throws org.kuali.rice.core.api.exception.RiceIllegalArgumentException
      Retrieve all the NaturalLanguageUsages
      Specified by:
      translateNaturalLanguageForProposition in interface TranslateBusinessMethods
      Returns:
      list of NaturalLanguageUsages
      Throws:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException

    • translateNaturalLanguageTreeForProposition

      NaturalLanguageTree translateNaturalLanguageTreeForProposition(String naturalLanguageUsageId, PropositionDefinition propositionDefinintion, String languageCode) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the given naturalLanguageUsageId, proposition, or language is null or invalid

    • findContextIds

      List<String> findContextIds(org.kuali.rice.core.api.criteria.QueryByCriteria queryByCriteria) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the queryByCriteria is null

    • findAgendaIds

      List<String> findAgendaIds(org.kuali.rice.core.api.criteria.QueryByCriteria queryByCriteria) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the queryByCriteria is null

    • findRuleIds

      List<String> findRuleIds(org.kuali.rice.core.api.criteria.QueryByCriteria queryByCriteria) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the queryByCriteria is null

    • findPropositionIds

      List<String> findPropositionIds(org.kuali.rice.core.api.criteria.QueryByCriteria queryByCriteria) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the queryByCriteria is null

    • findActionIds

      List<String> findActionIds(org.kuali.rice.core.api.criteria.QueryByCriteria queryByCriteria) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the queryByCriteria is null

    • selectContext

      ContextDefinition selectContext(ContextSelectionCriteria contextSelectionCriteria) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the implementation can't handle the given ContextSelectionCriteria
      See Also:

    • getAgendaTree

      @Cacheable(value="http://rice.kuali.org/krms/v2_0/AgendaTreeDefinition", key="\'agendaId=\' + #p0") AgendaTreeDefinition getAgendaTree(String agendaId) throws org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.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 org.kuali.rice.core.api.exception.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:
      org.kuali.rice.core.api.exception.RiceIllegalArgumentException - if the given list of agendaIds is null