Kuali Rice 2.1.0-M2 Release Notes

Released: 04-09-2012

Kuali Rice 2.0 Overview

Welcome to Kuali Rice version 2.0!

This is the first major release of the Kuali Rice software since version 1.0 which was released in August of 2009. This release brings many new and exciting features and improvements to the Kuali Rice middleware and application development platforms.

The primary architectural goal for this release of Rice was to position the platform for cross-version service compatibility moving forward. With the increase in the number of applications (both internal and external to Kuali) that are integrating with the Kuali Rice middleware platform, the ability to provide for compatibility across different versions of Kuali Rice has risen to the forefront within the community as a critical need. The end result is intended to be a platform on which institutions can build applications without worrying about major forced upgrade paths for all integrated applications whenever they deploy a new release of Kuali Rice.

Another major effort that was undertaken in support of compatibility work was an effort to improve the modularity of the various components of Kuali Rice. In version 1.0.x of Rice, a high degree of coupling was present in numerous places. Work was done as part of this release to help improve upon that situation.

In addition to the architectural efforts supporting compatibility and modularity, Kuali Rice 2.0 sees the introduction of two new major modules.

The first of these is the Kuali Rapid Application Development (KRAD) module. KRAD is meant to provide the next generation of application development capabilities to those who are building applications based on Kuali software. KRAD provides a platform that can be utilized to build enterprise applications in a way that provides a more rich and flexible user experience than could be provided with the existing Kuali Nervous System (KNS). In fact, KRAD is intended to be the eventual replacement for the KNS which is the platform upon which much of the existing Kuali application software has been written. Note, however, that KNS is not being removed as of Rice 2.0. Work will continue on KRAD past the 2.0 release of Kuali Rice.

The final major piece of functionality that was undertaken for this release was the introduction of the Kuali Rule Management System (KRMS). KRMS is a business rule management system which can be used to author and maintain business rules that can be utilized during decision making processes within an application. This includes the ability to use business rules defined in KRMS to define rules for workflow routing, notification, validation, and other custom scenarios.

More details on each of the major efforts can be found in later sections of this document.

Release Highlights

Highlights of this release include:

Refactoring of all remotely accessible services to position them for cross-version compatibility with future versions of Kuali Rice. This includes a migration from Java serialization-based services to SOAP-based web services.
Reduction in the number of places where a Kuali Rice client application will interact directly with the Kuali Rice standalone server database (when using integration models like embedded KEW).
Improvements to the Kuali Service Bus to allow it to support requirements for version compatibility.
Introduction of a new approach to server and client-side caching use the Spring caching abstraction coupled with Ehcache. This includes a new user interface for managing caches.
Breakdown of the codebase into smaller modules to increase modularity and flexibility of the software.
Numerous improvements to the design and documentation of Kuali Rice apis.
Integration of an out-of-the-box LDAP connector for Kuali Identity Management.
Introduction of the Kuali Rules Management System (KRMS) module for creation and execution of business rules.
Introduction of the concept of PeopleFlows in Kuali Enterprise Workflow.
Introduction of the Kuali Rapid Application Development (KRAD) module, the next revision of the KNS which includes rich UI features and is based on Spring MVC instead of Struts.
Ability to configure Bitronix as a JTA alternative to JOTM and XAPool.
Many of the Kuali Rice library dependencies have been updated.

Download

Kuali Rice 2.1.0-M2 can be downloaded from the Rice website at http://kuali.org/rice/download.

There are three different distributions of Rice available: source, binary and server. Please read the Installation Guide for more details on each of these distributions.

Documentation

API Documentation can be found at http://site.kuali.org/rice/2.1.0-M2/apidocs/index.html

Formal documentation can be found at http://site.kuali.org/rice/2.1.0-M2/reference/html/portal.html. This documentation is still in the process of review and update for 2.0 which will continue through subsequent releases, so please follow the notes in each document to report any outdated information.

Contact

If you encounter any difficulty, please don't hesitate to contact the Rice team on our public collaboration mailing list at <rice.collab@kuali.org>. Please indicate that you are using the 2.1.0-M2 version of Rice.

Major Changes

As mentioned in the overview and highlights, there were many major changes that were made in support of the goals of the Rice 2.0 release. During the implementation of modularity and version compatibility changes, there were many structural improvements and refactoring changes to Rice that are intended to help set a stronger foundation for future releases. Additionally, the KRMS and KRAD modules brought a large amount of new functionality to the Kuali Rice platform. These next sections dive into these changes in more detail.

Middleware Version Compatibility

In Rice 2.0, we are providing what we call "middleware" or "service" compatibility. This type of compatibility is mainly concerned with compatibility between a client application and the version of the Kuali Rice standalone server with which it is integrated. The basic requirement here is that if the Kuali Rice standalone server (which hosts all of the Kuali Rice services) is upgraded to a new version, that should not force any applications that integrate with those services to also upgrade (unless the server has been upgraded to a new "major" version such as Rice 3.0, 4.0, etc.). It should be able to continue to interoperate with the new set of services without having to pull in new Kuali Rice client libraries or (in the case of manual web-service integration) it should not have to modify the way in which it invokes and handles remote service calls.

The image below shows what the target is for version compatibility from the perspective of major, minor, and patch releases of Kuali Rice.

The type of compatibility being implemented for version 2.0 is in contrast to what we call "framework" compatibility, or the ability to upgrade a client application to a new version of the Kuali Rice client libraries or development framework without having to make any forced changes to that client application. Those who use Java are familiar with this type of compatibility because that is the level of compatibility that is generally provided between releases of the JDK (this is sometimes called a "drop-in" replacement). Working toward a goal of framework compatibility is on the roadmap for the Kuali Rice project, however the Rice 2.0 release makes no guarantees that it will provide such a level of compatibility moving forward.

More info on this and also Framework Version Compatibility can be found in our Kuali Rice Version Compatibility Statement.

The following sub-sections will delve into some specific work that was done in support of version compatibility.

Migration to SOAP web services

In Kuali Rice 1.0.x, services based on Java serialization were the primary services used for integration between Kuali Rice and client applications. The mechanism by which serialization was performed used Spring's HTTP invoker remoting framework. Java serialization is convenient for Java-to-Java application interaction. However, a SOAP web service approach allows for a greater level of interoperability between applications, including those not written in Java. Additionally, serialization can sometimes inherently cause compatibility issues when attempting to communicate between applications which might be running different versions of Java or different versions of libraries.

To this end, the services in Rice 2.0 have all been reimplemented as SOAP-based web services. There will be no Java-serialization based service distributed with Kuali Rice 2.0. However, the Kuali Service Bus will still support publishing of services that use Java. As part of this effort, the team has taken care to carefully design the message formats such that:

The "required" portions of the message format are well-defined
The proper format of data in the messages in well-defined
Error and exception cases are well-defined
The services are designed to allow for safe evolution over time
The services are namespaced and named appropriately
The services are versioned appropriately
There is consistency in how services are designed and documented

Much of the above information can be found in the WSDL's which are generated for each of the services. The WSDL defines the message formats, operations, and error conditions of the numerous Kuali Rice services. This effort of service refactoring is at the heart of what we are calling "version compatibility" for the Kuali Rice 2.0 release.

Note that while SOAP is being used as the primary way in which services are exposed in Rice 2.0, there will likely be work in the future to make services available using the REST architectural style.

Kuali Service Bus

In order to support requirements for version compatibility, there were numerous changes that needed to be made to the Kuali Service Bus. This ultimately resulted in a reworking of much of the internals of the KSB (with the exception of it's messaging functionality). The major changes made to the KSB for Kuali Rice 2.0 were:

Client applications now connect to the service registry through a SOAP web service, rather than through direct connections to the KRSB_SVC_DEF_T and related tables.
There is a new API for the ServiceBus which is well documented and acts as the client application interface point with the KSB.
The practice of storing a java serialized form of the service configuration in the database was altered to store an XML-serialized service descriptor. This allows for more portability and greater access for non-Java applications to interact with the service bus.
Removed the faulty "dead service" indicator from the registry.
Added the concept of a service status to the registry.
Added service version number information to the registry.
Replaced the concept of the "service namespace" with the concept of an "application id".
Introduced the concept of an "instance id" which identifies an instance of an application. This allows the KSB to better handle applications that are clustered with multiple deployments all publishing the same set of services.
Much more flexibility in how a client application can configure and use the KSB. For example, a client application could just configure the KSB client to act as a publisher of a service, or it could just connect to the KSB as a consumer of services. As well as additional configuration permutations related to support for reliable messaging and "development" mode (where services are not actually published).
A general refactoring of the internal architecture of the KSB related to handle it handles the publishing lifecycle of services as well as synchronization with the shared service registry.

As can be seen from the list above, much work was done to the service bus for Kuali Rice version 2.0. For more details, read the following page https://wiki.kuali.org/x/T3dyEg

Parameter Service, Namespace Service, and Component Service

In Rice 1.0.x, parameters, namespaces, and components were part of the KNS module of Rice. Client applications would access tables in the Kuali Rice server database directory in order to read and write values from these tables. As part of the general effort to modularize the Rice platform, it was decided that these three concepts were core concepts since they were used outside of the pure application development domain of the KNS (parameters in particular are used all over the Kuali Rice codebase). To this end they were moved to the newly established "core" module of Rice (see more information on modularity work in later sections).

Additionally, SOAP services were created for each of these to eliminate the need for a client application to directly communicate with the related database tables, instead using a service-oriented approach to interacting with these different information sources. This resulted in the creation of the following services:

org.kuali.rice.core.api.parameter.ParameterRepositoryService - remote service which provides operations related to system parameters
org.kuali.rice.core.api.namespace.NamespaceService - remote service which provides operations related to namespaces
org.kuali.rice.core.api.component.ComponentService - remote service which provides operations related to components, as well as implementing a new model for publication of "derived" components

For working with parameters, there is still a ParameterService this is provided as part of the client-side API. This service is configured with the application id of the application and delegates calls down to the remote ParameterRepositoryService.

For the ComponentService, it provides a new mechanism for publication of "derived" components, which can include components that are derived from an application's data dictionary configuration. This is a replacement for the "getNonDatabaseComponents" method which was part of the RiceApplicationConfigurationService in Rice 1.0.x. It uses a push model in contrast to the pull model which was used in Rice 1.0.x.

More information about these individual services and their available operations can be found in the javadocs. Also see the following page for more details on the work that was done with these services, including a description of the new model used for publication of derived components: https://wiki.kuali.org/x/tg5yEg

RiceApplicationConfigurationService

In Rice 1.0.x, the RiceApplicationConfigurationService was a service published by all KNS applications which provided callbacks into the application from the Kuali Rice standalone server. This service was removed in Rice 2.0 for various reasons. The reasons for it's removal and information on it's effective replacements can be found on the following page: https://wiki.kuali.org/x/vA6tEg

General Purpose Lookup APIs

In Rice 1.0.x, may of the services (particularly the KIM services) had general-purpose lookup methods which took a Map<String, String>. In this map, the key was intended to represent the property name on the data element being looked up and the value was intended to be the value to search for. The value itself could contain various wild card characters and other operators to allow for the construction of more complex searches. However, there were a few inadequacies with this approach:

If an institution wanted to implement their own version of the service, they would effectively need to implement a complex interpreter which would take the incoming String value and determine how to implement the lookup according to the values passed in.
There was no way to preform cross-property "ors" with this model.
There was no support for "paging" of query results.
The contract itself tended to be weakly defined, resulting in service methods that would be hard to maintain from a service compatibility perspective.

To this end, some work was done to design a general purpose lookup API that could be applied in a standard fashion across the various Rice services which needed it. The following page describes more about the various possibilities for implementing this as well as the solution which was chosen: https://wiki.kuali.org/x/PR9yEg.

The implementation of this api can be found on the core-api module under the package org.kuali.rice.core.api.criteria.

Kuali Enterprise Workflow Services

The Kuali Enterprise Workflow services have been refactored for version compatibility in a similar fashion to the rest of the services in Rice. As part of this effort, a bit of a rearchitecture of the service layer and APIs for workflow were performed as well. The major changes made to the workflow services and apis are as follows:

The WorkflowDocument class is now an interface and is created using WorkflowDocumentFactory.createDocument or WorkflowDocumentFactory.loadDocument instead of creating new instances through the WorkflowDocument constructor.
SimpleDocumentActionsWebService was combined with WorkflowDocumentActions to create the new WorkflowDocumentActionsService remotable service.
WorkflowInfo and WorkflowUtility was removed and replaced with the following services:
- WorkflowDocumentService
- ActionListService
- DocumentTypeService
- NoteService
- RuleService
The various KEW framework services were refactored to conform to service version compatibility standards. This includes services for document search customization, action list customization, workflow notes, document security, rule validation, and workflow rule attributes.
The various KEW message queues were refactored to conform to service version compatibility standards. This includes queues for document routing, blanket approval, immediate email reminders, searchable attribute indexing, document requeuing, etc.
In the KNS, both KualiWorkflowInfo and KualiWorkflowDocument were removed as it was deemed this duplicate level of abstraction was unnecessary. In the case of KualiWorkflowDocument, existing references were changed to just WorkflowDocument. In the case of KualiWorkflowInfo, code was changed to call one of the new KEW services that was added in Rice 2.0.

WorkflowDocument.returnToPreviousNode Signature Updates

With 2.0, the exiting method singature for WorkflowDocument.returnToPreviousNode takes in two String arguments of nodeName and annotation, was mistakenly reversed. This has been fixed in the upcoming Rice 2.0.1 release with [KULRICE-6863] by setting the method back tovoid returnToPreviousNode(String annotation, String nodeName);

Additionally, Rice 2.0 introduced a new WorkflowDocument.returnToPreviousNode that has the signature of void returnToPreviousNode(ReturnPoint returnPoint, String annotation); To keep the signature consistent with the String, String version, this has also been updated in 2.0.1 to be void returnToPreviousNode(String annotation, ReturnPoint returnPoint); Early adopters of 2.0 that may have implemented the new method will need to be sure to update any calls to this new method.

Document Search

One of the major KEW framework refactorings that was undertaken for Rice 2.0 was a reimplementation of the various components that support Document Search customization. Full documentation on these changes and how to utilize them is still in progress, but a summary is as follows:

SearchableAttribute - class still named the same but moved to a different package, method names changed, returns RemotableAttributeField instead of List<Row>
Client applications no longer allowed to override or use these attributes:
- DocumentSearchCriteriaProcessorAttribute
- DocumentSearchGeneratorAttribute
- DocumentSearchResultProcessorAttribute
- DocumentSearchXMLResultProcessorAttribute
The only valid document search-related attributes are now:
- SearchableAttribute
- DocumentSearchCustomizer
- DocumentSecurityAttribute
The DocumentSearchCustomizer replaces most of the original document search-related attributes. It is a single attribute which allows for customization of criteria, results, and various other aspects of the Document Search operation.
The customizer itself is not remoted, instead a DocumentSearchCustomizationHandlerService is published by each KEW client application. This allows for a client application to implement as many customizers as they want and map them to the document types they should apply to via DocumentType configuration. The Document Search functionality itself will then callback into the client application when it needs to via the published DocumentSearchCustomizationHandlerService.
The new document search framework uses the RemotableAttributeField abstraction for defining fields that should be displayed as extra search criteria. This is in contrast to Rice 1.0.x where KNS Row and Field objects were transmitted using Java serialization. This old model did not translate well to SOAP-based services and had numerous other problems as well (namely that not all of Field and Row was properly serializable or could be interpreted correctly by the Rice standalone service, such as custom formatters, values finders, etc.).

Further documentation on how to migrate from the old document search framework to the new document search framework is forthcoming. For the time-being, the best resource is to look at the javadocs for the org.kuali.rice.kew.framework.document.search package. All of the framework apis should have fairly thorough javadocs.

Caching Architecture

In Rice 1.0.x, caching was implemented using a framework called OSCache along with distributed caching flushing behavior across the KSB. This worked well in general, however this setup was plagued by issues of far too many cache-related message events getting generated and sent. Additionally, OSCache is a long-dead project which has not had any activity in a long time. In order to ensure that Kuali Rice was positioned for service compatibility moving forward, an effort was undertaken to revamp and update the caching architecture utilized by the Rice platform and find a better and more sustainable solution.

The result is a solution based on the caching abstraction provided with the core Spring framework version 3.1. The backend caching implementation being used is Ehcache (which is the default recommended by Spring). There is a also integration with the Kuali Service Bus for sending cache eviction messages out to interested listeners. This allows us to keep our caching consistent across different applications in an enterprise architecture which has been integrated with Kuali Rice.

More details on the specific work that was done to rearchitect the Kuali Rice caching infrastructure can be found here: https://wiki.kuali.org/x/XgmWEg

Modularity

In version 1.0.x of Kuali Rice, the software was divided into 3 main modules: api, impl, and web. While this was convenient from the development perspective, it resulted in a high level of coupling between the various "logical" modules of Rice (the core, kew, kim, ksb, etc.). Attempts were made to rectify some of these issues in Kuali Rice 2.0. Since the full vision for modularity in Kuali Rice was not in scope for the 2.0 release, as much work was done on modularity as could be permitted in order help reach version compatibility goals for the release.

Primarily, this included the creation of numerous "api" and "framework" modules and the partitioning of Kuali Rice into various sub-project modules. This structure can be seen when looking at the source code for Rice 2.0. The design and vision for modularity in Kuali Rice can be found at the following links:

PeopleFlows

Core PeopleFlow concept

A new concept was added to Kuali Enterprise Workflow as part of workflow routing requirements for Kuali Coeus. The requirement was essentially to replicate the functionality of "Maps" in the existing Coeus system upon which Kuali Coeus is based. These maps are simply lists of people or roles who can approve in a particular order. This order is defined by a series of "stops". At each stop there can be a number of possible approvers which may have delegates.

There was not really an equivalent concept in KEW today, this is essentially like a mini-workflow itself. So the concept of PeopleFlows were added along with a new activation type called "Priority-Parallel" activation. This priority-parallel activation allows for action requests to be activated at a node in parallel if they have the same priority, but in sequence if they have different priority values.

Further details on the implementation of PeopleFlows, their lineage in Coeus, as well as some screenshots of the maintenance user interface can be found here: https://wiki.kuali.org/x/3R6REg

PeopleFlow integration with KRMS

The previous section introduced the concept of PeopleFlows. The KRMS module will have integration with PeopleFlows built in through the use of a custom type of "Action". This action will allow a rule author to build a business rule and then indicate that the action that should be executed if the rule succeeds would be to route to the specified PeopleFlow.

Details on the way this integration is implemented can be found here: https://wiki.kuali.org/x/3R6REg

New Modules: KRMS and KRAD

Kuali Rapid Application Development Framework (KRAD)

KRAD (Kuali Rapid Application Development) is a framework that eases the development of enterprise web applications by providing reusable solutions and tooling that enable developers to build in a rapid and agile fashion. KRAD is a complete framework for web development that provides infrastructure in all major areas of an application (client, business, and data) and integrates with other modules of the Rice middleware project. KRAD is the next generation of the Rice Kuali Nervous System (KNS) and Kuali Student development frameworks. It expands on the ability to rapidly create user interfaces with XML while providing more flexibility with layouts and user experience. In addition, KRAD allows for the creation of modern, rich user interfaces using the jQuery and Fluid frameworks.

How does KRAD improve on the KNS? See Benefits of KRAD.

To learn more about KRAD, please visit the following pages:

In addition, see various analysis pages here (Note: some of the information might be incomplete or out of date): KRAD Analysis

Kuali Rule Management System (KRMS)

KRMS (Kuali Rule Management System) is a new module in Rice that enables the externalization of pieces of business logic (rules) from an application such that it is customizable without need for additional client programming. Agendas containing custom business rules can be defined, edited and stored in the repository, and then executed by the application against some set of information (facts).

There is also integration between KRMS and KEW's new PeopleFlow concept that enables invocation of the rule execution engine from within a workflow. Rules can be configured with PeopleFlow actions that specify PeopleFlows to route to or to notify.

View the following analysis page for some additional information on KRMS:KRMS Analysis

Configuration Changes

For Rice 2.0, we now support:

Tomcat 6 (Servlet API 2.5, JSP 2.1)
Tomcat 7 (Servlet API 3.0, JSP 2.2)

With this change, we have dropped support for Tomcat 5.5 (Servlet API 2.4, JSP 2.0).

Library Changes and Additions

There were many changes made to the various direct and transitive dependencies for Kuali Rice. Additional documentation can be found in the upgrade guide about what the specific changes were, but the following is a summary of some of the highlights:

Spring 3.1
Apache CXF 2.3.6
OJB 1.0.4-patch7
- includes various patches from the Kuali community
Direct Web Remoting (DWR) 3.0.RC2
Ehcache 2.4.6
Groovy 1.8.1
joda-time 2.0
JOTM 2.1.9
Bitronix 2.1.1
Quartz 1.8.4
Spring Security 3.0.7
Struts 1.3.10
Tiles 2.2.2
jQuery 1.6.3

Other Changes

There were many other changes made in Kuali Rice 2.0 which are not included in the previous section. The following list is a highlight of some of these. For a comprehensive list of changes that were performed, see the section called “Items Addressed in Rice 2.0”

Removal of DateUtils and NumberUtils
Changes in how unit tests and integration tests are run
Addition of Priority parallel activation type
Use of immutable objects and the builder pattern for various APIs
Removal of "object remoting" functionality from the KSB
Conversion of identifiers from numeric to character-based data types in KEW
Changes to PersistableBusinessObjectBase and notes
Normalization on a single concept of "application id"
Unique constraint on kim permission namespace:name and responsibility namespace:name
Clean up of multiple "key-value-pair" style classes
Transition from custom-written email services to standardizing on the spring mailer
Move to Maven version 3
DateTimeService converted to use configuration parameters instead of system parameters, allowing for it to be used through more of the system without the need for database dependencies
Kuali Communication Broker (KCB) integration turned off by default
Removal of IdentityManagementService, replaced with individual service calls in KIM
Replacement of AttributeSet in KIM service apis with simple Map<String, String>
Renaming of various data elements in KIM to more closely align with PESC standards
Ability for a RouteModule to be called back into multiple times in order to generate more requests in support of new PeopleFlow feature
Hours of availability awareness
Change from WorkflowFunctions to EDLFunctions (and package name changes) in eDocLites
Ability to define finer-grained Action List notification preferences for KEW

Upgrade Guide

Upgrade Considerations

This section outlines the process of upgrading from Rice 1.0.3.3 to Rice 2.0.0. If you are curently running an older version of the 1.0.x code, you will need to perform the steps to upgrade to 1.0.3.3 first.

In terms of upgrading to Kuali Rice 2.0, there are two main types of upgrades which will typically need to be performed:

Kuali Rice Standalone Server
Client Applications

Since Rice 2.0 is not backward compatible with 1.0.x, upgrades to both the standalone server and any client applications which are using the Rice APIs will need to be coordinated to occur at the same time.

It is likely that an institution which has built multiple custom Kuali Rice applications will need to perform both of these steps and coordinate the upgrade appropriately within their enterprise. For the other Kuali applications within the Kuali Foundation, each of the projects are planning forthcoming releases which will support Rice 2.0. So it would be advisable to wait until those upgraded versions are available before taking on an enterprise-wide upgrade of Kuali Rice infrastructure to avoid needing to manually convert these applications yourself. Please consult the time lines of the other Kuali projects for details on their planned migrations to Rice 2.0.

For those applications which are running Kuali Rice in "Bundled" mode (which means the application is not dependant on a separate Kuali Rice Standalone Server instance) then both types of upgrades will need to be performed on the same application.

In addition to upgrading the Rice standalone server and any integrated client applications, any use of the Kuali Rice data in downstream systems (such as a Data Warehouse or reporting environment) needs to be considered. There have been impacting changes to the Rice database tables as part of development on version 2.0. Therefore, existing reports may not work as desired and should be updated and tested appropriately.

In the following sections, we will describe the upgrade process for each of the different areas in detail.

Upgrading a Kuali Rice Standalone Server

The Kuali Rice Standalone Server is made available as a WAR and deployed to a servlet container (typically Tomcat). The general process for upgrading a standalone server from version 1.0.3.3 to version 2.0 will be as follows:

Re-apply local customizations
Upgrade Workflow Plugins
Upgrade the Database
Update Configuration
Deploy

Re-apply Local Customizations

Many who have implemented Kuali Rice have performed local customizations to the software. This might include patching bugs, adding additional features, or overriding reference service implementations (especially in the case of Kuali Identity Management). Additionally, customization may have been done to some of the web content that's included as part of the KNS framework.

It is, of course, important that these local customizations be reapplied to your Kuali Rice 2.0 implementation as part of your upgrade process. You may be accomplishing this in many different ways currently, the most common approaches include the following:

Using Maven WAR overlays to construct a custom Rice Standalone WAR.
Using a build tool like Apache Ant to manually assemble a custom WAR file.
Using a custom Ant build, the Maven shade plugin, or a similar tool to patch Rice code.
Extending delivered Kuali Rice code or reference service implementations and loading them via the rice.additionalSpringFiles configuration parameter to perform service overrides.
Customizing web content by modifying the delivered Kuali Rice JSP and tag libraries.
Modifications to the web.xml file to include additional web application configuration or modify supplied configuration (i.e. the "environment" init-param in the packaged web.xml).

Regardless of the approach or approaches you are utilizing, it's important to ensure your customizations are transfered properly. The code base of Kuali Rice has changed significantly during the 2.0 development cycle. As a result, it is suggested that you port over any code or file customizations one class at a time to ensure they get rewritten if needed to link and compile properly with the 2.0 libraries.

Upgrade Workflow Plugins

If your Rice server is loading any KEW plugins, then these will need to be upgraded as well. At the very least, this will likely involve recompilation and repackaging to link with the Rice 2.0 apis. Depending on how much code is in the plugin and which Rice frameworks it utilizes, it's likely that plugin code will need to be upgraded in a similar fashion to client application code in order for it to work properly within the Rice plugin framework. See the Client Application portion of the upgrade guide for more information on this.

Upgrade the Database

The Rice Standalone Server download will be packaged with database upgrade scripts included. These are located in the following directory:

scripts/upgrades/1.0.3 to 2.0.0

Within this directory, are the following relevant sub-directories:

final - contains the SQL needed to perform a full database upgrade from a Kuali Rice 1.0.3.3 standalone server database to 2.1.0-M2. There are scripts here for both the client database upgrade (which will be discussed in more detail in a later section) as well as the standalone server database. There are Oracle and MySQL versions of each of these.
demo-data - this directory contains updates to the various pieces of Kuali Rice demo data. Typically when performing an upgrade it will be against a database that does not have demo data. But these scripts are provided just in case they are needed.
support - this directory contains a groovy script which helps deal with the fact that unique constraints were added to the database for the combination of namespace code and name in both the KIM permission and responsibility tables.
xml-ingest-updates - contains XML that needs to be ingested after the database upgrade is completed

The steps to perform the standalone server database upgrade will be as follows:

Generate upgrade script for KIM Permission and Responsibility name uniqueness, execute these scripts.
Execute the "final" standalone server database upgrade scripts.
Perform maintainable XML conversion
Perform manual XML ingestion after standalone server startup

KIM Permission and Responsibility Uniqueness

As part of Rice 2.0 development, a new constraint was put in place which requires that the combination of namespace code and name on Permission and Responsibility records in KIM must be globally unique. This means that the combination of the NMSPC_CD and NM columns in the KRIM_PERM_T and KRIM_RSP_T tables must be unique within each one of these tables.

The "final" upgrade scripts that are provided with the upgrade add the constraints to these tables. Therefore, in order to prevent this portion of the upgrade from failing, it's important to ensure the data in these tables conforms to the new uniqueness constraints before they are applied to the tables.

Preferably, for any potentially duplicate records you have in this table, you will examine each and come up with a reasonably descriptive and unique name for each permission and responsibility record. However, if this is not feasible or too time consuming, a set of scripts come with the standalone server download which will generate UPDATE SQL for you. In order to use these scripts you must first have Groovy 1.8 installed on the machine from which you will run the scripts. You must also know the details to connect up to the Rice database for which you want to generate upgrade SQL.

It's important to note that these scripts will not update any data in your database, they will just read the data located therein and produce output to the terminal window.

In order to run the script, follow these steps:

Download the Rice Standalone Server distribution if you have not done so already and unzip it.
Open a command-line window and change directory to the scripts/upgrades/1.0.3 to 2.0.0/support directory.

Execute a command similar to the following (enter on a single line in the terminal):

If using MySQL:

groovy -cp /java/drivers/mysql-connector-java-5.1.17-bin.jar DbUpdateTool.groovy
    jdbc:mysql://localhost:3306/myricedb db-username db-password PermissionsNamespaceNameUniquifier

If using Oracle:

groovy -cp /java/drivers/ojdbc6.jar DbUpdateTool.groovy
    jdbc:oracle:thin:@localhost:1521:ORACLE db-username db-password PermissionsNamespaceNameUniquifier

In the examples above, be sure to change the "-cp" argument to point to the MySQL jdbc driver if you are using MySQL or the Oracle jdbc driver if you are using Oracle. If you don't have the appropriate driver you will need to download it to a location of your choosing. You will also need to pass the appropriate database connection arguments as well.

This command will read the KIM permission data in your database and determine which records violate the new uniqueness constraints and then generate appropriate SQL that can be used to update the records to make them unique. The output might look similar to the following:

$ groovy -cp /java/drivers/ojdbc6.jar DbUpdateTool.groovy
    jdbc:oracle:thin:@localhost:1521:ORACLE db-username db-password PermissionsNamespaceNameUniquifier
Loading command PermissionsNamespaceNameUniquifier
Loading command ResponsibilityNamespaceNameUniquifier
java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
Excluding: [PERM_ID:[140, 141, 142, 143, ...]]
Executing: 
        select * from KRIM_PERM_T where (NMSPC_CD,NM) in (
            select NMSPC_CD,NM from KRIM_PERM_T group by NMSPC_CD,NM having count(*) > 1
        )
         and PERM_ID not in (140,141,142,143, ...)

Generating transformation SQL:

update KRIM_PERM_T set NM='Modify Accounting Lines 199' where PERM_ID='199';
update KRIM_PERM_T set NM='Modify Accounting Lines 200' where PERM_ID='200';
update KRIM_PERM_T set NM='Initiate Document 202' where PERM_ID='202';
update KRIM_PERM_T set NM='Administer Routing for Document 203' where PERM_ID='203';
update KRIM_PERM_T set NM='Administer Routing for Document 204' where PERM_ID='204';
update KRIM_PERM_T set NM='Use Transactional Document 206' where PERM_ID='206';
...

Done.

Execute the same command as above but pass "ResponsibilityNamespaceNameUniquifier" as the last argument to generate the update SQL for KIM responsibilities.
At this point you can copy the output between "Generating transformation SQL" and "Done" for both permissions and responsibilities and create an SQL script to run as the first step of your database upgrade.

From the example above, you can see that the script just generates the unique name based on the id of the permission or responsibility. If you want different behavior you can modify the Groovy scripts or update the data manually using a strategy of your choosing for making the data unique.

Execute Final Upgrade Script

Once you have a script to update your permission and responsibility tables in KIM for name uniqueness, you are ready to execute the final upgrade script.

There is SQL available for this for both MySQL and Oracle in the scripts/upgrades/1.0.3 to 2.0.0/final directory in the standalone server download. You will want to execute one of the following depending on whether the database you are upgrading is MySQL or Oracle:

MySQL - update_final_mysql.sql
Oracle - update_final_oracle.sql

Be sure to prepend the SQL generated for KIM data updates to your upgrade scripts and then run the full script against your database to perform the upgrade using an SQL tool of your choice.

Test!

It is recommended that you test the database upgrade against a copy of your production database before performing it against your actual production database. In particular, if your database is at all sizable, then it could take a long time for certain portions of the script to execute since they have to rebuild some of the tables in the Rice database. It is also recommended that you back up your production database before performing the upgrade in case there is a problem during the conversion process and you need to roll back.

Maintainable XML

There was work done in Rice 2.0 which might invalidate legacy KNS maintenance framework XML causing exceptions to occur when attempting to load this XML (which is generated using the XStream library) back into an instance of the business object class being maintained. This data is stored in the KRNS_MAINT_DOC_T table in the DOC_CNTNT column. In order to address this, a program was written that can be executed to perform the needed maintainable XML conversion. This program is included in the rice-development-tools module of Kuali Rice. Instructions on how to set up the tool and run it can be found in it's javadocs located here:

http://site.kuali.org/rice/2.1.0-M2/apidocs/org/kuali/rice/krad/maintainablexml/ConvertMaintainableXML.html

Caution

While this utility is available, it was difficult for the Kuali Rice team to be able to test this tool with a lot of different maintenance document scenarios. We suggest that this conversion be tested thoroughly by those using the conversion utility prior to performing the upgrade in production. This means performing the conversion and then verifying the ability to open and route to completion maintenance documents which were ENROUTE at the point-in-time of upgrade.

XML Ingestion

There is currently no (easy) way to perform XML ingestion while the Kuali Rice Standalone server is offline. However, there are some XML files which should be ingested as part of the Rice 2.0 upgrade. These files are located in the scripts/upgrades/1.0.3 to 2.0.0/xml-ingest-updates directory of the standalone server distribution.

Once the database has been upgraded and you have successfully started your version 2.0 Kuali Rice Standalone Server, you can use the XML Ingester screen in order to ingest these files. Most of these files are related to setting up KEW configuration for the new KRMS module. So if you are not planning to take advantage of this new module immediately, you do not need to do this ingestion right away.

Update Configuration

The most frequently customized configuration parameters which are used by the standalone server have not changed a whole lot between Rice 1.0.x and 2.0. However there are a few changes which are important to note.

First of all, in Rice 1.0.x there was a configuration parameter named rice.additionalSpringFiles. This was used to load custom Spring files into the standalone server (or a client application) which could be used to override internal Kuali Rice services for the purposes of customization. In Rice 2.0, there is no longer a single rice.additionalSpringFiles parameter. Instead there is one per module of Rice such as rice.kew.additionalSpringFiles, rice.ksb.additionalSpringFiles, rice.kim.additionalSpringFiles, etc. When re-applying and loading customizations, this needs to be taken into account. Additionally, you will need to ensure you are overriding the service in the appropriate module or else the service override will not take effect.

Additionally, the caching implementation for Rice has been reworked to use the Ehcache library. As a result, the various kim.cache.* configuration parameters are no longer available. Instead, when needing to customize how caching for KIM (or any other module of Rice) is configured, a custom ehcache configuration file can be loaded through configuration parameters like kim.ehcache.config.location, kew.ehcache.config.location, etc.

Generally speaking, for configuration parameters which you are using and overriding as part of your standalone server setup, it's best to look at the value in the configuration defaults for Rice to determine if or how it has changed in Rice 2.0. The source for that configuration default file can be found here:

http://svn.kuali.org/repos/rice/tags/rice-2.1.0-M2/impl/src/main/resources/META-INF/common-config-defaults.xml

Encryption Key Update in Override Cases

If you override the encryption key, there is an extra step that needs to be done to ensure users have acces to existing workflow documents. Due to the move from commons-codec 1.3 to 1.6 in Rice 2.0 and the way the library works in the face of improperly padded base64 strings, the encryption.key configuration property needs to be updated to ensure that it has the correct padding.. We've provided a utility for doing this and it's located here…

http://svn.kuali.org/repos/rice/tools/encryption-key-converter/trunk

To run this…

Check out out the app above
Run mvn package from the command line to create the executable jar in the target folder
Run the executable in the target directory with java -jar encryption-key-converter-1.0-SNAPSHOT.jar <current encryption.key property value>
1. So if the old key was 7IC64w6ksLR and the new key is 7IC64w6rAAAA the command would be:
  java -jar target/encryption-key-converter-1.0-SNAPSHOT.jar 7IC64w6ksLR

Note

The app contains the commons-codec 1.3 inside of the executable so there's no need to grab it elsewhere.

Deploy

Once you have completed updating your standalone server's configuration, you are ready to do deploy it. This process still works largely the same as it did in Rice 1.0.x. However, in Rice 2.0, Tomcat 6 or Tomcat 7 is recommended. It is not recommended to run the Kuali Rice Standalone Server in Tomcat 5.5.x as was the case with Rice 1.0.x.

As part of this, you should ensure that the "lib" directory of your Tomcat instance has the appropriate JDBC driver for the database you are using.

If you have any trouble with this step, please consult the section called “Troubleshooting”.

Upgrading a Client Application

Upgrading a Kuali Rice client application is a bit more involved than upgrading the Kuali Rice standalone server. This is because there is no easy "automatic" upgrade path and there will likely be a significant amount of manual work which will need to be done in your application code in order to perform the upgrade. This is because of a few different reasons:

Many of the service APIs were redesigned in support of version compatibility.
There was a large amount of "repackaging" of existing Rice code which was done as part of a modularization effort in Rice 2.0.
Some classes were removed because of redundancies or inconsistencies in the APIs.
The way that Rice is configured in Spring has changed.

In addition to this, you will want to ensure that your application is only using the allowed API and framework classes from the Kuali Rice libraries in order to ensure that your application will remain compatible across releases of Kuali Rice. See the version compatibility documentation for more details.

The next few sections will take you through the process of upgrading a client application as well as providing additional resources to help you with the process.

Client Database Upgrade

While there were not a lot of database changes made to the database tables that a Kuali Rice client application uses, there were a few. Those changes are fairly minor, however, and can be summarized as follows:

Added OBJ_ID and VER_NBR columns to the KRNS_SESN_DOC_T tables.
On the KRSB_MSG_QUE_T table, changed SVC_NMSPC column to APPL_ID.
On the KRNS_DOC_HDR_T table changed the size of the FDOC_DESC column from 40 to 255 characters.

Those are the only structural changes which need to be made to existing client application databases. MySQL and Oracle scripts for performing these updates are available in the following locations in the Rice distribution downloads:

MySQL: scripts/upgrades/1.0.3.3 to 2.0.0/final/update_client_final_mysql.sql
Oracle: scripts/upgrades/1.0.3.3 to 2.0.0/final/update_client_final_oracle.sql

Finally, the KRNS_MAINT_DOC_T table which includes maintainable XML will be in each client application which uses the KNS. If your application uses maintenance documents, you will need to perform the maintenance XML upgraded as described earlier in the section called “Maintainable XML”.

Library Upgrades

As mentioned previously, there have been numerous 3rd-party dependency updates in this version of Rice. Additionally, modularity work that was done during this release has resulted in a more granular set of Rice libraries. All of these library dependencies are included with the binary distribution of Kuali Rice. Additionally, if an application is using Maven, all of the Rice dependencies are available in the Maven Central Repository under the org.kuali.rice group id: http://search.maven.org/#search|ga|1|g%3A%22org.kuali.rice%22

Details on the library changes will be outlined in the next few sections. You will need to update the libraries associated with your existing project as necessary in order to react to this. What follows are tables detailing libraries added, removed, and changed from Rice 1.0.3.3 to Rice 2.0. In addition to this information, detailed dependency analysis can be found on the Maven-generated site for Kuali Rice http://site.kuali.org/rice/2.1.0-M2/index.html

Be Careful!

Even if you may not need one of the libraries listed below as a Rice dependency, your application may be using it for something else. So be sure to verify whether or not you are using a particular library in your application independently of Rice before you remove it from your project.

Kuali Rice Libraries

In Rice 1.0.x, there were only two main jars, rice-api and rice-impl. With the modularity work there are more api jars corresponding to service apis and framework components. Additionally, the implementation module has been split (though there is still a shared implementation module as not all components of the Rice implementation have been fully modularized as of the Rice 2.0.0 release). This work was done according to the design outlined at the following page: Modularity Design

Old Library	New Library
rice-api-1.0.3.3.jar	rice-core-api-2.0.0.jar
	rice-core-framework-2.0.0.jar
	rice-core-service-api-2.0.0.jar
	rice-core-service-framework-2.0.0.jar
	rice-edl-framework-2.0.0.jar
	rice-ken-api-2.0.0.jar
	rice-kew-api-2.0.0.jar
	rice-kew-framework-2.0.0.jar
	rice-kim-api-2.0.0.jar
	rice-kim-framework-2.0.0.jar
	rice-kns-2.0.0.jar
	rice-krad-app-framework-2.0.0.jar
	rice-krad-web-framework-2.0.0.jar
	rice-krms-api-2.0.0.jar
	rice-krms-framework-2.0.0.jar
	rice-ksb-api-2.0.0.jar
	rice-location-api-2.0.0.jar
	rice-location-framework-2.0.0.jar
rice-impl-1.0.3.3.jar	rice-impl-2.0.0.jar
	rice-core-impl-2.0.0.jar
	rice-core-service-impl-2.0.0.jar
	rice-edl-impl-2.0.0.jar
	rice-kew-impl-2.0.0.jar
	rice-kim-impl-2.0.0.jar
	rice-krms-impl-2.0.0.jar
	rice-ksb-client-impl-2.0.0.jar
	rice-ksb-server-impl-2.0.0.jar
	rice-location-impl-2.0.0.jar
rice-sampleapp-1.0.3.3.jar	rice-core-service-web-2.0.0.jar
	rice-core-web-2.0.0.jar
	rice-ksb-web-2.0.0.jar
	rice-location-web-2.0.0.jar

Libraries Added between 1.0.3.3 and 2.0.0

Library Added	Notes
aspectjrt-1.6.8.jar
aspectjweaver-1.6.8.jar
avalon-framework-4.1.5.jar
btm-2.1.2.jar	Only needed if using Bitronix for your connection pooling
carol-interceptors-1.0.1.jar
commons-chain-1.2.jar
cxf-rt-transports-common-2.3.8.jar
ehcache-core-2.5.0.jar
guava-11.0.jar
hibernate-core-3.6.9.Final.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
hsqldb-1.8.0.1.jar
irmi-1.1.2.jar
jackson-core-asl-1.8.7.jar
jackson-mapper-asl-1.8.7.jar
jacorb-2.2.3-jonas-patch-20071018.jar
jacorb-idl-2.2.3-jonas-patch-20071018.jar
jcl-over-slf4j-1.6.4.jar	Needed only if you use JCL.
joda-time-2.0.jar
logkit-1.2.jar
serializer-2.7.1.jar
slf4j-api-1.6.4.jar
slf4j-log4j12-1.6.4.jar
spring-asm-3.1.0.RELEASE.jar
spring-tx-3.1.0.RELEASE.jar
spring-expression-3.1.0.RELEASE.jar
spring-security-cas-3.1.0.RELEASE.jar
spring-security-core-3.1.0.RELEASE.jar
spring-security-web-3.1.0.RELEASE.jar
stax2-api-3.1.1.jar
struts-extras-1.3.10.jar
struts-taglib-1.3.10.jar
tiles-api-2.2.2.jar
tiles-core-2.2.2.jar
tiles-jsp-2.2.2.jar
tiles-servlet-2.2.2.jar
tiles-template-2.2.2.jar
woodstox-core-asl-4.1.1.jar

Library Version Changes between 1.0.3.3 and 2.0.0

Old Library	New Library	Notes
asm-2.2.3.jar	asm-3.3.1.jar	It's very important that you verify that you do not have asm-1.5.3.jar on your classpath. This will cause Apache CXF to function improperly when making SOAP service calls.
bcprov-jdk15-1.45.jar	bcprov-jdk16-1.46.jar	The Bouncy Castle Crypto package is used for cryptographic algorithms.
carol-2.0.5.jar	carol-3.0.6.jar
cas-client-core-3.1.6.jar	cas-client-core-3.2.1.jar
cglib-nodep-2.1_3.jar	cglib-nodep-2.2.2.jar
commons-beanutils-1.7.0.jar	commons-beanutils-1.8.3-kuali.jar
commons-codec-1.3.jar	commons-codec-1.6.jar
commons-collections-3.2.jar	commons-collections-3.2.1.jar
commons-dbcp-1.2.1.jar	commons-dbcp-1.4.jar
commons-digester-1.6.jar	commons-digester-2.0.jar
commons-fileupload-1.2.1.jar	commons-fileupload-1.2.2.jar	Struts dependency
commons-httpclient-3.0.1.jar	commons-httpclient-3.1.jar
commons-io-1.4.jar	commons-io-2.1.jar
commons-lang-2.3.jar	commons-lang-2.6.jar
commons-pool-1.2.jar	commons-pool-1.5.7.jar	Used by OJB (and others)
commons-validator-1.1.4.jar	commons-validator-1.3.1.jar	Struts dependency
cxf-api-2.2.9.jar	cxf-api-2.3.8.jar
cxf-common-schemas-2.2.9.jar	cxf-common-schemas-2.3.8.jar
cxf-common-utilities-2.2.9.jar	cxf-common-utilities-2.3.8.jar
cxf-rt-bindings-soap-2.2.9.jar	cxf-rt-bindings-soap-2.3.8.jar
cxf-rt-bindings-xml-2.2.9.jar	cxf-rt-bindings-xml-2.3.8.jar
cxf-rt-core-2.2.9.jar	cxf-rt-core-2.3.8.jar
cxf-rt-databinding-aegis-2.2.9.jar	cxf-rt-databinding-aegis-2.3.8.jar
cxf-rt-databinding-jaxb-2.2.9.jar	cxf-rt-databinding-jaxb-2.3.8.jar
cxf-rt-frontend-jaxrs-2.2.9.jar	cxf-rt-frontend-jaxrs-2.3.8.jar
cxf-rt-frontend-jaxws-2.2.9.jar	cxf-rt-frontend-jaxws-2.3.8.jar
cxf-rt-frontend-simple-2.2.9.jar	cxf-rt-frontend-simple-2.3.8.jar
cxf-rt-transports-http-2.2.9.jar	cxf-rt-transports-http-2.3.8.jar
cxf-rt-ws-addr-2.1.5.jar	cxf-rt-ws-addr-2.3.8.jar
cxf-rt-ws-security-2.1.5.jar	cxf-rt-ws-security-2.3.8.jar
cxf-tools-common-2.1.5.jar	cxf-tools-common-2.3.8.jar
db-ojb-1.0.4-patch4.jar	db-ojb-1.0.4-patch8.jar
displaytag-1.1.jar	displaytag-1.2.jar
dwr-1.1.3.jar	dwr-3.0.RC2.jar	In DWR 3.0 all logging is done through the commons-logging API. Please see the following website for more information: http://directwebremoting.org/dwr/documentation/server/configuration/servlet/index.html
groovy-all-minimal-1.5.4.jar	groovy-all-1.8.5.jar
hibernate-commons-annotations-3.0.0.ga.jar	hibernate-commons-annotations-3.2.0.Final.jar
hibernate-entitymanager-3.3.1.ga.jar	hibernate-entitymanager-3.6.9.Final.jar
howl-logger-0.1.11.jar	howl-1.0.1-1.jar
javassist-3.3.ga.jar	javassist-3.15.0-GA.jar
jaxb-impl-2.1.9.jar	jaxb-impl-2.1.13.jar
jaxb-xjc-2.1.9.jar	jaxb-xjc-2.1.13.jar
jdom-1.0.jar	jdom-1.1.jar
jettison-1.2.jar	jettison-1.3.jar
jotm-2.0.10.jar	jotm-core-2.1.10.jar
jsr311-api-1.0.jar	jsr311-api-1.1.1.jar
jstl-1.1.2.jar	jstl-1.2.jar
jta-1.0.1B.jar	jta-1.1.jar
log4j-1.2.14.jar	log4j-1.2.16.jar
mail-1.4.jar	mail-1.4.4.jar
neethi-2.0.4.jar	neethi-2.0.5.jar
spring-2.5.6.jar	spring-3.1.0.RELEASE.jar	spring-3.1.0.RC1.jar can be included either as a single jar or the multiple jars listed below
spring-aop-2.5.6.jar	spring-aop-3.1.0.RELEASE.jar
spring-beans-2.5.6.jar	spring-beans-3.1.0.RELEASE.jar
spring-context-2.5.6.jar	spring-context-3.1.0.RELEASE.jar
spring-context-support-2.5.6.jar	spring-context-support-3.1.0.RELEASE.jar
spring-core-2.5.6.jar	spring-core-3.1.0.RELEASE.jar
spring-jdbc-2.5.6.jar	spring-jdbc-3.1.0.RELEASE.jar
spring-orm-2.5.6.jar	spring-orm-3.1.0.RELEASE.jar
spring-tx-2.5.6.jar	spring-tx-3.1.0.RELEASE.jar
spring-webmvc-2.5.6.jar	spring-webmvc-3.1.0.RELEASE.jar
spring-web-2.5.6.jar	spring-web-3.1.0.RELEASE.jar
struts-1.2.9.jar	struts-core-1.3.10.jar
struts-el-1.2.9.jar	struts-el-1.3.10.jar
xalan-2.7.0.jar	xalan-2.7.1.jar
XmlSchema-1.4.5.jar	XmlSchema-1.4.7.jar
xmlsec-1.4.3.jar	xmlsec-1.4.4.jar
wss4j-1.5.8.jar	wss4j-1.5.11.jar

asm

This is mentioned in the table above, but just to reiterate, it is very important that you verify that you do not have asm-1.5.3.jar on your classpath. This will cause Apache CXF to function improperly when making SOAP service calls.

spring-webmvc-struts.jar

Note: As of Spring 2.5, Spring Web MVC is no longer part of the 'spring.jar' file. Spring MVC can be found in 'spring-webmvc.jar' and 'spring-webmvc-portlet.jar' in the lib/modules directory of the distribution. Furthermore, the Struts 1.x support has been factored out into 'spring-webmvc-struts.jar'. Rice itself does not use spring-webmvc-struts.jar, but if you were including the spring-2.0.4.jar and using the spring web mvc struts functionality, spring-webmvc-struts.jar will now have to be included separately.

Libraries Removed between 1.0.3.3 and 2.0.0

Old Library
abdera-core-1.0.jar
abdera-extensions-json-1.0.jar
abdera-extensions-main-1.0.jar
abdera-i18n-1.0.jar
abdera-parser-1.0.jar
acegi-security-1.0.6.jar
acegi-security-cas-1.0.6.jar
activation-1.1.jar
antlr-2.7.6.jar
asm-attrs-1.5.3.jar
axiom-api-1.2.5.jar
axiom-impl-1.2.5.jar
bcel-5.1.jar
bsf-2.4.0.jar
casclient-2.1.1.jar
cas-server-3.0.4.jar
concurrent-1.3.4.jar
derby-10.2.2.0.jar
geronimo-activation_1.1_spec-1.0.2.jar
geronimo-annotation_1.0_spec-1.1.1.jar
geronimo-javamail_1.4_spec-1.3.jar
geronimo-jaxws_2.1_spec-1.0.jar
geronimo-stax-api_1.0_spec-1.0.1.jar
geronimo-ws-metadata_2.0_spec-1.1.2.jar
hibernate-3.2.6.ga.jar
hibernate-annotations-3.3.0.ga.jar
hibernate-validator-3.0.0.ga.jar
jaxb-api-2.1.jar
jaxb-xjc-2.1.13.jar
jaxen-1.1.3.jar
jboss-common-core-2.0.4.GA.jar
jotm_jrmp_stubs-2.0.10.jar
js-1.6R5.jar
nekohtml-0.9.5.jar
oscache-2.3.2.jar
persistence-api-1.0.jar
saaj-api-1.3.jar
saaj-impl-1.3.2.jar
spring-test-2.5.6.jar
standard-1.1.2.jar
wstx-asl-3.2.9.jar
xml-apis-1.0.b2.jar
xmlbeans-2.4.0.jar
xom-1.1.jar

Unchanged Libraries

Library
aopalliance-1.0
commons-logging-1.1
commons-transaction-1.1
connector-api-1.5
dom4j-1.6.1
itext-1.3
jaxb-impl-2.1.13
oro-2.0.8
spring-modules-ojb-0.8a
wsdl4j-1.6.2
xercesImpl-2.9.1
xml-resolver-1.2
xpp3_min-1.1.3.4.O
xstream-1.2.2

Web Content Changes

For applications which are using the KNS, some of the web content has changed. This web content includes images, javascript, css, jsp, and tag library files. When using the KNS these are typically copied into the application. Therefore when performing an upgrade, the original KNS web content should be deleted from the project and the new web content from Rice 2.0.0 should be copied into it's place.

However, if the client application has made customizations to any of these resources then they will need to manually reapply any customizations they have made. In order to aid in this process, information on which web content files have changed can be found here:

Indiana University Notes on Web Content Updates

Rice Configurer Changes

Previously, all module configuration was done via a class wired in Spring called the RiceConfigurer. This has been replaced by a modular configuration design, with the rice core being configured in a new CoreConfigurer. Each module has it's own configurer as well (KEWConfigurer, KIMConfigurer, etc..). Run modes are set independently for each module and additional spring files are now defined on a per-module basis as discussed in the standalone server upgrade portion of this document.

An example Spring configuration which would load all of the available Rice modules into a client application would look like the following:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

  <bean id="config"
        class="org.kuali.rice.core.impl.config.property.ConfigFactoryBean"
        p:initialize="true">
    <property name="configLocations">
      <list>
        <value>classpath:config.xml</value>
      </list>
    </property>
  </bean>

  <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
        p:properties="#{config.getProperties()}"/>

  <bean id="jtaTransactionManager"
        class="org.springframework.transaction.jta.JotmFactoryBean">
        p:defaultTimeout="3600"/>
    
  <bean id="riceDataSource"
        class="org.kuali.rice.core.framework.persistence.jdbc.datasource.XAPoolDataSource"
        p:transactionManager-ref="jtaTransactionManager"
        p:driverClassName="${datasource.driver.name}"
        p:url="${datasource.url}"
        p:maxSize="${datasource.pool.maxSize}"
        p:minSize="${datasource.pool.minSize}"
        p:maxWait="${datasource.pool.maxWait}"
        p:validationQuery="${datasource.pool.validationQuery}"
        p:username="${datasource.username}"
        p:password="${datasource.password}"/>

  <bean id="riceNonTransactionalDataSource"
        class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close"
        p:driverClassName="${datasource.driver.name}"
        p:url="${datasource.url}"
        p:maxActive="${datasource.pool.maxActive}"
        p:minIdle="${datasource.minIdle}"
        p:initialSize="${datasource.initialSize}"
        p:validationQuery="${datasource.pool.validationQuery}"
        p:username="${datasource.username}"
        p:password="${datasource.password}"
        p:accessToUnderlyingConnectionAllowed="${datasource.accessToUnderlyingConnectionAllowed}"/>

  <bean id="coreConfigurer"
        class="org.kuali.rice.core.impl.config.module.CoreConfigurer"
        depends-on="config"
        p:transactionManager-ref="jtaTransactionManager"
        p:userTransaction-ref="jtaTransactionManager"
        p:dataSource-ref="/>

  <bean id="ksbConfigurer" class="org.kuali.rice.ksb.messaging.config.KSBConfigurer"/>
  <bean id="kradConfigurer" class="org.kuali.rice.krad.config.KRADConfigurer"/>
  <bean id="coreServiceConfigurer" class="org.kuali.rice.coreservice.impl.config.CoreServiceConfigurer"/>
  <bean id="kimConfigurer" class="org.kuali.rice.kim.config.KIMConfigurer"/>
  <bean id="kewConfigurer" class="org.kuali.rice.kew.config.KEWConfigurer"/>
  <bean id="krmsConfigurer" class="org.kuali.rice.krms.config.KRMSConfigurer"/>
  <bean id="locationConfigurer" class="org.kuali.rice.location.impl.config.LocationConfigurer"/>

</beans>

For the example above, most all of these modules would be running in the REMOTE run mode. That is the default with the exception of CoreConfigurer and KRADConfigurer which always run in LOCAL module and don't have a REMOTE run mode. It's important in these cases to load the Rice common-config-defaults.xml file into your configuration context so that the appropriate defaults can be applied.

The following example shows doing this as well as switching the KIM and KEW run modes to "embedded" mode:

<config>
  <param name="config.location">classpath:META-INF/common-config-defaults.xml</param>
  ...
  <param name="kew.mode">EMBEDDED</param>
  <param name="kim.mode">EMBEDDED</param>
  ...
</config>

Note that if you were in fact configuring KEW and KIM for embedded mode you would also need to inject a serverDataSource into the CoreConfigurer which would point to your Kuali Rice Standalone Server database.

API Changes

More information on some of the specific API changes which were made for the various Rice modules can be found in the Indiana University upgrade notes on impacting changes.

Data Warehouse and Reporting

If you have written any reports against your Kuali Rice database tables, they may need to be updated to reflect changes to the database tables in version 2.0. Generally speaking, the changes to database tables is not extensive, but here is a summary of some of the significant changes that have been made:

The DOC_HDR_ID and other numeric identifiers in the KREW_* tables have been changed to VARCHAR data types. This facilitates more flexibility in the kind of data which can be stored in these tables and brings the KEW tables in line with other tables in Kuali Rice.

The following tables were renamed:

Table 1. Renamed Tables

Old Table Name	New Table Name
KRNS_NMSPC_T	KRCR_NMSPC_T
KRNS_PARM_TYP_T	KRCR_PARM_TYP_T
KRNS_PARM_DTL_TYP_T	KRCR_CMPNT_T
KRNS_PARM_T	KRCR_PARM_T
KRNS_CAMPUS_T	KRLC_CMP_T
KRNS_CMP_TYP_T	KRLC_CMP_TYP_T
KR_COUNTRY_T	KRLC_CNTRY_T
KR_STATE_T	KRLC_ST_T
KR_POSTAL_CODE_T	KRLC_PSTL_CD_T
KR_COUNTY_T	KRLC_CNTY_T
KREW_STYLE_T	KRCR_STYLE_T

Additional changes which might affect reporting can be found in the final upgrade SQL scripts.

Troubleshooting

The amount of work done in Kuali Rice version 2.0 was fairly significant, therefore it is likely that there are some gaps this upgrade guide. If you encounter problems when attempting your upgrade, please do the following:

Check the Kuali Rice 2.0 - Upgrade Troubleshooting page in the Kuali Rice wiki. This page will contain some FAQ's and any necessary addendums to this upgrade guide.
If you don't find your answer there, join the <rice.collab@kuali.org> mailing list and post your questions there. You can join this mailing list through the Kuali Information System at http://kuali.org/kis

Items Addressed in Rice 2.0

Bug Fix

[KULRICE-2511] - Issues during DD Validation
[KULRICE-2758] - Split KNS services for local vs. embedded
[KULRICE-3054] - text area limit not implemented properly, such that it is not enforced if there is more than one text area on the page
[KULRICE-3473] - merge-module-classpaths ant target doesn't work anymore as groovy files have been removed from scripts/
[KULRICE-3648] - Convert the static non-final variables in StandardDocumentSearchGenerator into instance variables
[KULRICE-3908] - Approve fails to clear out saved ad hoc route requests...
[KULRICE-3925] - Impex appears to be broken with Ant 1.8.0
[KULRICE-3951] - log4j settings are not being respected. FIx logging mess.
[KULRICE-3956] - fix eclipse's complaing with cobertura.classpath not being a valid reference in build.xml
[KULRICE-3971] - update the coverage report to filter out test classes
[KULRICE-4006] - Rice 1.1 missing the stax-api-1.0-2 jar
[KULRICE-4098] - KRNS_SESN_DOC_T table does not have OBJ_ID and VER_NBR columns to work with PersistableBusinessObjectBase
[KULRICE-4140] - KimTypeInfoService cannot be accessed by "remote" KIM clients directly
[KULRICE-4155] - kim documents set boolean to on/off, rather than tru/false and do not use the boolean var/char converter to make Y/N in DB
[KULRICE-4541] - Service Registry page in KSB shows no services in Rice 1.1
[KULRICE-4553] - KEW is publishing services to the registry with bad service names like "enWorkflowUtilityService", etc.
[KULRICE-4560] - KimTypeService should not use KeyLabelPair
[KULRICE-4561] - Indicate First Name and Last Name are required on Person document
[KULRICE-4577] - DataDictionaryIndex looking at wrong map for duplicate document entry check
[KULRICE-4804] - maven no longer executing tests for empty packages
[KULRICE-4812] - cannot add a principal to a group when principal is already a non direct memeber of that group
[KULRICE-4893] - EmploymentStatus and EmploymentType not showing on Person document
[KULRICE-5012] - permission property name cannot exceed 40 characters
[KULRICE-5015] - Fix problem with document routing and Notes
[KULRICE-5016] - Current use of "runPostProcessorLogin" on WorkflowEngine is not thread safe
[KULRICE-5022] - RoleServiceImpl.getRoleQualifiersForPrincipalIncludingNested(..) returns wrong result
[KULRICE-5024] - JSP pages using display-el tag not working in rice 1.1
[KULRICE-5031] - Occasional NullPointerExceptions in StyleableEmailContentServiceImpl
[KULRICE-5040] - DataExporter class in KNS does not flush outputstream after export which can result in truncated xml files
[KULRICE-5061] - Re-implement ThinClientKEWConfigurer in face of modularity changes
[KULRICE-5078] - MultiLookup Export functionality failing for pages spilling beyond a certain size
[KULRICE-5087] - External BO's are not working
[KULRICE-5089] - Nested KSB Calls failing due to Null LocaleResolver reference
[KULRICE-5097] - KIM Caches are not being flushed as required.
[KULRICE-5118] - Old attachments in Maintenance Documents not showing except on a document reload
[KULRICE-5120] - Deletes from a collection in a Maintenance Documents do not persist to BO table
[KULRICE-5122] - in rule engine, terms passed in to engine at execution time are not available in the term resolution engine
[KULRICE-5127] - Fix infinite recursion problem w/ GlobalResourceLoaderServiceFactoryBean
[KULRICE-5135] - fix ojb proxies for classes with protected setters
[KULRICE-5142] - Fix transaction issue with AbstractBoTest
[KULRICE-5147] - Errors generated in the Parameter Lookup because of changing of business object names
[KULRICE-5161] - treeNode.tag exhibits recursive tag problem on Linux in Jetty 7.4.1
[KULRICE-5163] - Action/return links not showing when returning back to lookups with breadcrumbs
[KULRICE-5188] - Need to remove ImmutableListAdapter and ImmutableCollectionAdapter from our service definitions and come up with a better solution because it is producing undesirable XML
[KULRICE-5190] - Remove KSBThinClientResourceLoader as it is no longer necessary
[KULRICE-5198] - Methods in BusinessObjectAuthorizationService assume an inquiry collection will contain objects of type BusinessObjectEntry
[KULRICE-5217] - patch commons-beanutils so that is handles generics and covariant returns correctly.
[KULRICE-5239] - Maintenance documents can't be submit for non-bo's in krad and no error message displaying or logged
[KULRICE-5240] - OptionsFinder set on AttributeDefinition not working
[KULRICE-5251] - Fix binding issues in TreeGroup and ComponentUtils that are preventing trees with AttributeFields in the nodes from rendering
[KULRICE-5253] - Maintenance Docs - Field change highlighting not working now
[KULRICE-5256] - Maintenance Docs - Fix issues with show/hide inactive rows
[KULRICE-5264] - KRAD: Need a table with selectable rows.
[KULRICE-5267] - Some quickfinders breaking in ActiveCollectionFilter
[KULRICE-5269] - KRAD test views: expand/collapse should be links
[KULRICE-5272] - KRAD - KS: Validation error should turn label red
[KULRICE-5273] - KRAD - KS Test View 1: Content in tab group needs float-clearing div
[KULRICE-5274] - KRAD: On Test View 1: Banking Info, non-table layout - labels need to be included in containing spans.
[KULRICE-5275] - KRAD - KS Test View: Requiredness asterisk should appear at end of label, not before.
[KULRICE-5277] - KRAD - Buttons with icons
[KULRICE-5278] - KRAD: Tab view should be permanent
[KULRICE-5279] - KRAD: Need File Uploader
[KULRICE-5289] - Lookup - Conditional enabling of 'return value' causes issues with the Lookup result table alignment
[KULRICE-5290] - Exception when returning to portal on closing inquiry/maint/lookup
[KULRICE-5296] - KRAD: data table breaks on window resize
[KULRICE-5299] - Add line on collections not checking required fields and not refreshing just the collection group
[KULRICE-5300] - Lookup parameters not working for field lookup
[KULRICE-5301] - Labels not getting picked up on error messages for collection fields
[KULRICE-5310] - In Agenda Editor: fix conditional display of expand all / collapse all links above agenda tree
[KULRICE-5312] - Look-ahead not working after cancelled lookup
[KULRICE-5313] - Lookup doesn't return properly when clicking "return" button
[KULRICE-5314] - KEN Notification's FYI / ACK buttons in detail view throw RuntimeException on click
[KULRICE-5317] - Lookup causes null error when building an inquiry link for a foreign key
[KULRICE-5322] - Inquiry link goes to new window instead of lightbox
[KULRICE-5324] - When multiple components have same bean definition in dictionary they get the same id assigned
[KULRICE-5337] - Sorting on data tables not working
[KULRICE-5338] - Data table does not resize correctly when page is initially small
[KULRICE-5340] - Determine why CXF Interceptor to enforce immutable lists/collections isn't working on remote tests
[KULRICE-5347] - Checkbox widget - not reflecting true state of active indicator
[KULRICE-5350] - KRAD: IE Bug - Hyperlinks aren't working
[KULRICE-5353] - jstree plugin isn't being loaded anymore
[KULRICE-5354] - Agenda Editor only functions after ReloadingDataDictionary reloads
[KULRICE-5355] - Lookup - return values opens new tab, the return target is not set
[KULRICE-5361] - fieldAttributeQuery causes Exception when input field is unspecified
[KULRICE-5362] - Loading panel does not close - when saving or submitting a document after a ajaxSubmit component update
[KULRICE-5400] - Case/When statement does not execute RequiredConstraint (SimpleConstraint) DictionaryValidatoinServiceImpl
[KULRICE-5403] - AttributeField requires p:conditionalReadOnly="true" in order for p:readOnly="true" to work
[KULRICE-5411] - fieldAttributeQuery does not populate readOnly fields
[KULRICE-5415] - when attempting to ajax update a component in the page, get a spring EL exception
[KULRICE-5430] - Control still required when ControlField is provided
[KULRICE-5433] - ValidCharactersConstraint used in a CaseConstraint does not get removed
[KULRICE-5436] - When trying to access a view by using just the viewId parameter a document class error is thrown by both inquiry and lookup
[KULRICE-5440] - AttributeField.getSecuredFieldValue() should not thow exception if either mask or partialmask not set
[KULRICE-5450] - The id property of PropertyReplacer components does not get set.
[KULRICE-5451] - Images missing on quickfinder, direct inquiry links, and section expand in KNS and KS styles
[KULRICE-5452] - Quickfinder links returning 404
[KULRICE-5454] - Don't validate sub-fields if the field on which they sit is null
[KULRICE-5456] - In Agenda Editor, deleting the first agenda item does not work
[KULRICE-5457] - Rice Dev: Workflow Statistics throws HTTP 500 Error
[KULRICE-5458] - Rice Dev: Role/Group/Permission/Responsibility Type throws HTTP500 Error
[KULRICE-5459] - Rice Dev: Sercurity Management link not working
[KULRICE-5460] - Rice Dev: Action List Preferences Button Throws HTTP 500 Error
[KULRICE-5461] - Rice Dev: Action List Filter button gives error dump
[KULRICE-5462] - Rice Dev: User Preferences gives error message
[KULRICE-5463] - Rice Dev: Trying to open newly created Campus Maintenance eDoc from doc search throws error
[KULRICE-5464] - Rice Dev: Principal Name Lookup from Group Look bomb to error screen
[KULRICE-5465] - Rice Dev: Trying to Unsubscribe/Subscribe to Channel Subscriptions Fails
[KULRICE-5466] - Rice Dev: Document Search Help button not working
[KULRICE-5467] - Rice Dev: Trying to create new Person or edit existing yields error
[KULRICE-5468] - Rice Dev: KRAD breadcrumbs Home throws error
[KULRICE-5469] - Rice Dev: KRAD Breadcrumbs not updating correctly
[KULRICE-5470] - Rice Dev: KRAD Book Order Reqeust
[KULRICE-5471] - Rice Dev: KRAD Book Type Lookup bombs
[KULRICE-5472] - Rice Dev: KRAD Address Type Lookup bombs out
[KULRICE-5473] - Rice Dev: KRAD Author Lookup
[KULRICE-5474] - Rice Dev: KRAD Book Lookup dies
[KULRICE-5475] - Rice Dev: KRAD Incident Report gives error
[KULRICE-5476] - Rice Dev: KRAD Expand Icon on text fields missing as well as Loading Notification Icon
[KULRICE-5477] - Rice Dev: KRAD Travel Account Maintenance (new) error
[KULRICE-5478] - Rice Dev: KRAD Travel Account Maintenance (edit) error
[KULRICE-5479] - Rice Dev: KRAD Adding a row in Collection Group 1 does not save the sub acocunt or Travel Fiscal Officer ID
[KULRICE-5484] - Rice Dev: Trying to Open Blanket Approved Person doc, doc doesn't render
[KULRICE-5485] - Rice Dev: Group Lookup from Create Person bombs out
[KULRICE-5486] - Clicking out of lookup lightbox and then selecting add causes Exception
[KULRICE-5487] - On an inquiry lightbox off of a maintenance doc, clicking the "Close" button causes the browser to go back to the main portal tab
[KULRICE-5488] - Conditional properties using @{} syntax cause views to blow up when ReloadingDataDictionary reloads a view
[KULRICE-5489] - Rice Dev: Create New Person Doc doesn't Render
[KULRICE-5490] - Rice Dev: Create Group eDoc bombs on blanket approve
[KULRICE-5491] - Rice Dev: Person Inquiry Screen partially renders w/Error
[KULRICE-5493] - Rice Dev: KRAD, Sample Travel App bombing with Data Dictionary errors
[KULRICE-5495] - Rice Dev: Adding Ad Hoc recipient results in HTTP 500 error
[KULRICE-5496] - Rice Dev: Copy of existing rule gives error message
[KULRICE-5497] - Rice Dev: Create New Permission button bombs to error
[KULRICE-5498] - Rice Dev: Role Lookup from Create Person bombs out
[KULRICE-5499] - Rice Dev: Opening Saved Create Person eDocs with more than Name in Contact section won't render
[KULRICE-5520] - page's header menu bar has title/hover "Create a new record"
[KULRICE-5521] - Rice Dev: Group Lookup bombs if Principal Name is added
[KULRICE-5522] - Rice Dev: Blanket approve of edit Role document not routing properly
[KULRICE-5523] - Rice Dev: Permission Lookup bombs if Principal Name is added
[KULRICE-5524] - Rice Dev: Permission & Responsibility Lookups bomb if Group Name is added
[KULRICE-5528] - RuleRepositoryServiceImpl.getRules(List<String> ruleIds) doesn't support multiple elements in the ruleIds parameter
[KULRICE-5529] - Rice Dev: Action List bombs to HTTP 500 error
[KULRICE-5547] - KRAD: IE - unable to navigate to pages via the left navigation panel
[KULRICE-5548] - KRAD: IE is extremely slow to load pages
[KULRICE-5549] - Rice Dev: Ad Hoc Group Name lookup bombs on search
[KULRICE-5550] - Rice Dev: Group or Role lookup not returning values on Create Person
[KULRICE-5553] - Case/When not implemented properly
[KULRICE-5555] - after saving a maintenance doc, hitting the 'reload' button throws an exception
[KULRICE-5557] - KRAD: Incident Report - Stack Trace area needs a float clear
[KULRICE-5558] - Exception caused by defaultValue="true" of a check box
[KULRICE-5560] - Rice Dev: Create Person doc and Inquiry screen not rendering
[KULRICE-5562] - Rice Dev: Permission edit or copy results in error message
[KULRICE-5566] - Trouble unmarshalling rule attribute bo collection on save
[KULRICE-5567] - Parameter Maintenance Document does not check it's edit rules
[KULRICE-5572] - processCustomSaveDocumentBusinessRules Errors not being acknowledged on first save
[KULRICE-5576] - Rice Dev: Action List Preferences, checking the Current Route Node(s) causes error
[KULRICE-5577] - Remove Application Document Status from Action List Preferences since it is not displayed as a separate column
[KULRICE-5578] - Rice Dev: Action List Preferences, incorrect error messaging
[KULRICE-5579] - Rice Dev: Action List, Filter: selecting a Document Route Status causes error
[KULRICE-5580] - Rice Dev: Admin Identity Locations documents w/out required fields can be submitted
[KULRICE-5581] - Rice Dev: Create new Responsibility bombs out on required fields validation
[KULRICE-5582] - Rice Dev: Create new Routing Rule and Routing Rule Delegation bombs
[KULRICE-5583] - Rice Dev: eDocLite Example type bombs when trying to create new
[KULRICE-5586] - Rice Dev: KRAD, Horizontal Scroll bar Rendering outside frame
[KULRICE-5587] - In tree views, expand/collapse controls get redecorated by jstree and make the tree look funny
[KULRICE-5601] - Review patch for saved doc search putting field values in the wrong fields
[KULRICE-5616] - PersonServiceImpl.findPeopleInternal no longer supports search wildcards (including "!", "?", and "*")
[KULRICE-5639] - Within the date-picker widget, there are previous and next buttons. In IE, when hovering over these, the images flicker on and off. When clicking, nothing happens.
[KULRICE-5643] - ContextVariable 'LINE' not working with CollectionGroup.actionFields
[KULRICE-5663] - Nested KSB Calls failing due to Null LocaleResolver reference
[KULRICE-5667] - Drop indexes and constraints in 2011-06-17-m6.sql may cause problems for users attempting to upgrade
[KULRICE-5669] - Agenda Rule behaving badly if no context is specified
[KULRICE-5676] - Rice Dev: Clicking on Preferences from the Action list results in error
[KULRICE-5687] - Rice Dev: Direct Inquiry throwing Invalid path from all lookups
[KULRICE-5690] - Portal page re-sizing is broken
[KULRICE-5698] - edit links from the agenda lookup no longer work
[KULRICE-5699] - Rice Dev: Docs are not routing
[KULRICE-5700] - AgendaEditor view doesn't load due to view validation problems
[KULRICE-5705] - On document type lookup the inquiry link is missing on the document type id
[KULRICE-5707] - Direct inquiry empty check not working and cancel on lightbox not working
[KULRICE-5715] - Implement caching of legacy KEW rules on the RuleService by "doc type + rule template"
[KULRICE-5718] - When a document type is missing a NPE is thrown instead of DocumentAuthorizationException
[KULRICE-5722] - ProviderBasedEngine needs a new TermResolutionEngineImpl for each ExecutionEnvironment
[KULRICE-5725] - WorkflowDocument.isApprovalRequested() will return true for a role member who is part of an "all approve" role, but who has already approved
[KULRICE-5728] - Rice Dev: Blanket Approve action bombing out to exception
[KULRICE-5729] - Rice Dev: Group Lookup from Role maintenance document bomb to error
[KULRICE-5730] - Rice Dev: Trying to Send a Simple Notification results in error
[KULRICE-5731] - KRAD Rice Dev: Navigation side bar not rendering initially (KS L&F)
[KULRICE-5732] - KRAD: validation display in boxLayoutVerticalItem does not float correctly
[KULRICE-5736] - FieldUtils.convertRemotableAttributeField and related conversions to/from Row/Field/AttributeField/RemotableAttributeField not fully implemented
[KULRICE-5737] - Reimplement formatter support in StandardGenericXmlSearchableAttribute
[KULRICE-5741] - AJAX on tab-out for document type on document search is no longer working
[KULRICE-5743] - Add support for "max display length" on document search result columns
[KULRICE-5744] - Help link on document search should result to custom document type documentation when a document type is selected
[KULRICE-5748] - Validate that "to" dates are after "from" dates on document search
[KULRICE-5751] - "Clear Named Searches" no longer works in document search
[KULRICE-5752] - Reimplement ability to pass query parameters to Document Search
[KULRICE-5758] - "Group Viewer" lookup icon is missing from document search
[KULRICE-5759] - Agenda is not submittable due to xstream serialization issue
[KULRICE-5764] - SelectControl does not get translated in the lookup result or inquiry
[KULRICE-5766] - A re-approve of an edoclite form should continue to send emails to next in route path.
[KULRICE-5767] - edoclite disapprove does not send emails as expected to all persons in route path
[KULRICE-5768] - edoclite return to Previous does not send emails the the appropriate person in the route path
[KULRICE-5769] - edoclite user does not receive email when on multiple nodes of the workflow
[KULRICE-5772] - When field is required that uses a select control, clicking on the control to select a value gives the required error and kicks you out
[KULRICE-5773] - Fixing bugs found due to KULRICE-4794 - Change DOC_HDR_ID on KREW_DOC_HDR_T from a numeric type to a character type
[KULRICE-5774] - Nested bean of a collection not found when adding a collection item
[KULRICE-5776] - Button styling relies on container
[KULRICE-5777] - Lookup does not return value in Firefox 7.
[KULRICE-5778] - Error incident report throws NPE when DocumentAuthorizationException is thrown
[KULRICE-5781] - NotSerializableException on save/submit of a Maintenance document
[KULRICE-5782] - error during DataBinder initialization on certain actions
[KULRICE-5786] - Error messages not visible on sub-collection add line
[KULRICE-5789] - Revert UifControllerBase form creation methods
[KULRICE-5791] - DB Upgrade script 2011-09-18.sql attempting to drop a column that is referenced in a unique constraint
[KULRICE-5792] - KRMS Agenda Editor: css and js file references are appearing in <body> tag; should be in <head> tag
[KULRICE-5793] - Loading indicator does not display in lightbox
[KULRICE-5794] - Default values not working!
[KULRICE-5796] - progressive render of custom agenda attributes is broken
[KULRICE-5797] - Fix doc handler url in the AgendaEditor's doctype
[KULRICE-5799] - JS errors appear after going to doc search and then to another view
[KULRICE-5800] - RoleRouteModuleTest - RoleResponsibility approve policy determination
[KULRICE-5801] - Javadoc for WorkflowDocumentFactory claims to throw non-existent DocumentTypeNotFoundException
[KULRICE-5802] - DocumentTypeDao.findDocumentTypeIdByName is not considering the "current indicator" on the document type records
[KULRICE-5806] - Rice Dev: Inquiry and Create new screens/links dumping out to error
[KULRICE-5807] - Rice Dev: CSRF Security Error pop-up thrown on
[KULRICE-5809] - ComponentMaintenanceDocument document type missing
[KULRICE-5810] - three methods in DocumentSearchChiteriaBo.groovy call getPerson with the principal name rather than calling getPersonByPrincipalName
[KULRICE-5811] - KRAD: Selecting "Today" button needs to populate field with today's date
[KULRICE-5812] - JSP error on Service Registry page in Tomcat 7
[KULRICE-5815] - Parameter Maintainable
[KULRICE-5819] - Review and clean up parameter and component data in KRCR_PARM_T and KRCR_CMPNT_T
[KULRICE-5823] - make it so that attributes are not validated when eDocLite is canceled
[KULRICE-5827] - Fix suspicious MemberType/DelegationType conflation in ActionRequestFactory
[KULRICE-5829] - Add isMemberOfGroup back into EDLFunctions.java. Also contribute a few other methods as well.
[KULRICE-5831] - "Route Node Name" and "Route Node Logic" on document search are currently text fields and should be drop-down/select controls
[KULRICE-5832] - When saving a "detailed" search, it does not restore the doc search screen to the detailed search when loading the saved search
[KULRICE-5835] - changes to a field populated by fieldAttributeQuery.returnFieldMapping doesn't trigger progressive rendering based on that value
[KULRICE-5836] - values set on return from a fieldLookup that has parent="QuickFinderByScript" don't trigger progressive render
[KULRICE-5837] - When using the method getReportQueryIteratorByQuery, call releaseDbResources() to avoid INFO messages in the log
[KULRICE-5838] - Modify code which generates SQL for the detailed document search to treat the group ID as a string instead of a number to prevent a type casting issue in Oracle when the SQL is used.
[KULRICE-5839] - Avoid null pointer exception when ingesting a group without members.
[KULRICE-5841] - apostrophe character in watermarks breaks page js
[KULRICE-5843] - JSP Errors in Tomcat 7
[KULRICE-5846] - Rice Dev: Errors on Create New or Edit from Lookup on Group and Role
[KULRICE-5847] - Selecting FYI button in Action List results in looping page reload
[KULRICE-5851] - Rice Dev: Rice Maintenance documents bombing out to exception
[KULRICE-5854] - When using an "errors block" (all error messages grouped together) and a horizontal layout manager, we need wrapper around fields.
[KULRICE-5855] - Exception in incident report screen after authorization failure
[KULRICE-5856] - KRNS_DOC_HDR_T.FDOC_DESC column is only 40 char
[KULRICE-5858] - Trim the prefix value of whitespace
[KULRICE-5860] - Display user friendly message when direct inquiry is called on a non existing value.
[KULRICE-5861] - Account for brackets in the document title when doing doc search
[KULRICE-5862] - If any search criteria contained the word null, it caused an error
[KULRICE-5863] - Due to the outbox functionality, need to set the dateAssigned in DocumentOperationAction.java in case the action item being deleted should be placed in the outbox.
[KULRICE-5864] - In DocumentConfigurationViewAction, prevent null pointer exception if there are no route nodes on the document type.
[KULRICE-5867] - Make it so that document does not crash if an invalid network ID is passed in for an eDocLite field.
[KULRICE-5868] - Fix issue where we aren't properly checking for a null notification exclusion group
[KULRICE-5869] - Add a new formatter class (DateViewDateObjectFormatter.java), which displays the date as a date, but treats it like a timestamp.
[KULRICE-5870] - Missing div tag in RuleQuickLinks.jsp
[KULRICE-5874] - Rice Dev: Dev Not Working
[KULRICE-5875] - Missing Error Message Not Handled Well
[KULRICE-5876] - Rice Dev: Workgroup Inquiry screen from route log not showing assigned principals
[KULRICE-5877] - Rice Dev: Route log not sorting actions in ascending date/timestamp order
[KULRICE-5878] - Radiobuttons for Rule and Action subtypes should sort via seq_nbr
[KULRICE-5880] - Radiobuttons for Rule and Action subtypes should appear under types while not using space when not displayed.
[KULRICE-5885] - CSS clean up
[KULRICE-5887] - Left Navigation slow to load, shows up as links first
[KULRICE-5889] - Need "infinite scrolling table" in kitchen sink
[KULRICE-5890] - Need a tab navigation group in kitchen sink
[KULRICE-5894] - Improve documentation of AttributeError, especially for error messages
[KULRICE-5896] - Rice Dev: Error in Portal results in Frame Resizing Creep
[KULRICE-5897] - remove extra agenda.name field from the agenda editor
[KULRICE-5898] - Rule Editor has a duplicate Name field
[KULRICE-5899] - Agenda Editor allows add rule when (required) context has not been input
[KULRICE-5900] - Can not add a proposition to a new rule
[KULRICE-5903] - Text to make it more clear between Rule and Proposition tree sections.
[KULRICE-5904] - Make Proposition tree control more like the Rule tree control
[KULRICE-5905] - Validation Action custom attribute for message rather than using description
[KULRICE-5906] - Disable Rule Edit button when no rules are selected.
[KULRICE-5907] - Rice Dev: Permission Lookup Bombs if you specify a Template Namespace
[KULRICE-5908] - Rice Dev: Action List Preferences, selecting a color for disapproved or processed not working
[KULRICE-5909] - Deleted AgendaItem, Rule, Action are not removed from database on submit
[KULRICE-5911] - Rice Dev: SuperUser and Detailed Doc Search Not working in IE9 and Safari
[KULRICE-5912] - Rice Dev: KRAD Rendering issue with Cache Management Tool in Safari and IE9
[KULRICE-5913] - Edit Rule page should offer some information as to what Agenda we are in.
[KULRICE-5915] - Agenda Edit Rule button should be disabled if no rule has been selected.
[KULRICE-5918] - styling for selected item in agenda or rule tree is different (incorrect) for the last item in a sibling group
[KULRICE-5921] - Rice Dev: Person Inquiry Not Fully Loading
[KULRICE-5922] - Rice Dev: Role Create Document Formatting Issues
[KULRICE-5923] - Rice Dev: Responsibility Lookup Broken
[KULRICE-5924] - Rice Dev: Person and Group Maintenance documents not saving edits?
[KULRICE-5927] - Rice Dev: Role Create Document Permissions and Responsibilities lookups not working an
[KULRICE-5929] - KRAD: need ability to style Loading and Progress Indicators
[KULRICE-5930] - KRAD: Disclosure Collections not working in IE
[KULRICE-5936] - Logout Button errors out
[KULRICE-5938] - Javadoc on org.kuali.rice.kew.api.document.DocumentUpdate is inaccurate
[KULRICE-5943] - Agenda Namespace required bug alert workaround.
[KULRICE-5944] - Agenda Type Select has two blank selects.
[KULRICE-5945] - Put Rule Description back
[KULRICE-5952] - Term summaries are editable even when they shouldn't be
[KULRICE-5954] - In some cases changing the propositions in a rule doesn't update the proposition summary
[KULRICE-5957] - Several PermissionService methods cannot be used when making SOAP service call
[KULRICE-5963] - bug found in tag files due to changes made in KULRICE-4788 to prevent errors on lookups
[KULRICE-5964] - KSB republishing services
[KULRICE-5965] - KIM RoleService call leads to SQLException due to invalid column name in query
[KULRICE-5970] - Can not copy a permission
[KULRICE-5972] - Rice Dev: Going to XML Ingester screen gives error
[KULRICE-5977] - Add null checks in NoteServiceImpl to prevent error when delete button is double clicked
[KULRICE-5985] - Default link behavior for target should not be _blank, should be _self
[KULRICE-5986] - Iframe fields in IE have issues
[KULRICE-5988] - Iframe resize issue in Chrome
[KULRICE-5989] - Cross domain iFrame resize transition fix
[KULRICE-5993] - doc search view of krad maintenance doc shows hidden fields
[KULRICE-6000] - sequence number column in join table between parent and child propositions breaks agenda persistence
[KULRICE-6001] - Operator proposition parameters for propositions created in the UI are using with the wrong type code
[KULRICE-6002] - Category to Term progressive update only works when the edited node is also selected
[KULRICE-6004] - peopleflow name attribute validation causes exception at rule execution time
[KULRICE-6006] - TermResolvers need to be registered at execution environment setup time
[KULRICE-6008] - sortRoleMembers is missing from RoleTypeService
[KULRICE-6011] - Proposition tree data groups are not showing up
[KULRICE-6013] - SQLException when editing rule if there are no valid terms on a context
[KULRICE-6086] - Rice Dev: Service Registry Entries Throwing Error on Click
[KULRICE-6087] - Rice Demo: Service Registry Links Not showing WSDL info in Safari or Chrome
[KULRICE-6088] - Action list blows up if there are any items in it
[KULRICE-6090] - Create Person gives an error on sumission
[KULRICE-6091] - Exception in document search when searching with invalid criteria
[KULRICE-6093] - Agenda attributes are not being saved
[KULRICE-6094] - KRMS: Copy of a Term Specification or Agenda doesn't ever go any where on Submit/Blanket Approve
[KULRICE-6095] - KRMS: Copy of a Term bombs to exception on Submit/Blanket Approve
[KULRICE-6096] - KRMS: Edit of an Existing context not "routing" on submit or blanket approve
[KULRICE-6098] - Agenda qualifier matching is backwards
[KULRICE-6099] - KRMS (or KRAD): Data tables on KRMS lookups not sorting on column headings
[KULRICE-6100] - Rice Dev: Route Log Not showing entry when Return to Previous action is taken
[KULRICE-6101] - KRAD: frame sizing issue on Travel Account Lookup in Safari, Chrome, or IE9
[KULRICE-6271] - potential for post-authentication sql injection on document search
[KULRICE-6272] - log out should kill session
[KULRICE-6273] - cleanse channel urls, removing angle brackets
[KULRICE-6274] - Name suppression not functioning properly
[KULRICE-6279] - PeopleFlow Name UI does not show required, while the builder setRequired flag has been set.
[KULRICE-6280] - Can't edit existing rules in an agenda
[KULRICE-6283] - Rice Dev: Ad Hoc routing bombs on add person in Ad Hoc Recipients section
[KULRICE-6284] - Rice Dev: Document Search, clear saved searches button not working
[KULRICE-6289] - RelationshipDefinition requires BusinessObject class when it should just be Object
[KULRICE-6290] - Agenda copy and submit is broken because Document Description is not set
[KULRICE-6291] - title of lookup for adding multiple to a collection group should be generic
[KULRICE-6297] - AgendaItem move sometimes causes an NPE
[KULRICE-6300] - Travel Account link in KNS sample app throwing exception
[KULRICE-6302] - KIM RoleService call leads to SQLException due to invalid column name in query - Another instance
[KULRICE-6304] - java.lang.ClassCastException: org.kuali.rice.krad.uif.container.Group cannot be cast to org.kuali.rice.krad.uif.field.Field
[KULRICE-6307] - Incident report form does not get added to the session causing the submit report to fail
[KULRICE-6308] - Check support for expression placeholders in progressive, conditional render, refresh when changed properties
[KULRICE-6309] - JSP issue in SuperUser.jsp due to the use of the "final" reserved word.
[KULRICE-6310] - SQLException from ResponsibilityService due to invalid column name
[KULRICE-6311] - .size() calls in ToString() methods trigger JDBC calls and should be removed
[KULRICE-6312] - DictionaryObjectAttributeValueReader does not handle AttributeDefinitions that refer to a nested property within a collection (for usage in lookups)
[KULRICE-6313] - Copying a routing rule edits the original rather than creating a new rule
[KULRICE-6315] - Fix Validation Types
[KULRICE-6317] - Rice Dev: Routing & Identity Management Document Type Hierarchy bombs if you try to look at the doc config
[KULRICE-6318] - Rice Dev: Routing & Identity Management Document Type Hierarchy bombs if you try to search on edoc.example1
[KULRICE-6319] - RoleServiceImpl throws NullPointerException
[KULRICE-6320] - Allow passing in null PermissionDetails when having to perform generic permission match
[KULRICE-6323] - DataDictionaryTypeServiceHelper expects ValuesFinder definition for all kinds of remotable controls
[KULRICE-6333] - Adding to a sub-collection results in a new empty line on the last sub-collection off the primary collection
[KULRICE-6334] - On the rule editing page, the Edit rule action doesn't work on the first try
[KULRICE-6338] - Various issues getting KIM LDAP module to work properly
[KULRICE-6340] - ajax progressive disclosure / refresh are broken
[KULRICE-6344] - #dp doesn't work in progressiveRender
[KULRICE-6345] - On document search screen, the "Date Created From" field is no longer populated for searches when no criteria is provided.
[KULRICE-6346] - KRAD: TableLayoutManager Not Releasing Memory
[KULRICE-6347] - Rice 2.0 B3 only working after commenting out KCB configurations
[KULRICE-6348] - Navigation Tab styling was lost at some point for both L&F
[KULRICE-6353] - Add explicit dependency to asm version 3.3.1 in ksb-client-impl pom
[KULRICE-6355] - Javascript Error in IE & FF on Agende Lookup Screen
[KULRICE-6357] - When DelegateType is created on the fly by getPrimaryDelegation(), it can not be returned via service call
[KULRICE-6358] - refreshing components in the tree doesn't work, binding path gets mangled
[KULRICE-6361] - null dereference in disableButtons.js on refresh of Rule editor screen
[KULRICE-6364] - javascript error on adding a line to a collection on a Term Specification
[KULRICE-6365] - On rule screen, PeopleFlow ID lookup for action types can pull in bogus parameters
[KULRICE-6366] - covariant return of DataFieldSecurity in DataField.getComponentSecurity() breaks spring BeanWrapperImpl magic, TravelAccount lookup is broken as a result
[KULRICE-6367] - Rice Dev: Trying to Submit/Blanket Approve a Document Results in Error
[KULRICE-6368] - Rice Dev: Document Search not working
[KULRICE-6369] - Rice Dev: Rule Attribute bombs to exception on click
[KULRICE-6370] - Rice Dev: Rule Template bombs to error on Click
[KULRICE-6371] - Rice Dev: Document Type bombs to error on click
[KULRICE-6372] - Rice Dev: XML Stylesheets bombs to error on click
[KULRICE-6374] - Hidden fields not rendering on Inquiry Views
[KULRICE-6376] - Incident report does not display correctly when an exception is thrown in the view
[KULRICE-6377] - Remove single quotes from binding paths due to JS issues
[KULRICE-6382] - Image on spinner control doesn't appear until the control gets focus
[KULRICE-6385] - Exception in KIM Role Maintenance Screen
[KULRICE-6386] - IllegalAccessError from UIDocumentService while maintaining custom Roles
[KULRICE-6388] - Class cast exception when doing an edit/copy on the Maintainable documents
[KULRICE-6392] - Receiving JS error on DataTables: Uncaught TypeError: Cannot read property 'oFeatures' of null http://dev1.rice.kuali.org/krad/scripts/jquery/jquery.dataTables.js 3982
[KULRICE-6393] - PeopleFlow members show up as secondary delegates in the route log
[KULRICE-6400] - "even" and "odd" text is showing up in table elements (myplan)
[KULRICE-6403] - Div id, span id, label for, and other values use number, not natural language
[KULRICE-6409] - Field groups in collection lines do not get binding correctly prefixed
[KULRICE-6410] - ajax refreshes are broken on the agenda tree and the rule (proposition) tree
[KULRICE-6412] - ARIA statements require mods to Doctype
[KULRICE-6414] - Label for collection field does not show/hide correctly with progressive disclosure or refresh
[KULRICE-6416] - Rice Dev: Pages on KRAD tab not loading
[KULRICE-6426] - Rice Dev: Initiator direct Inquiry from Document Search throwing HTTP 500 Error
[KULRICE-6440] - Read only view of maintenance document leaves input field editable
[KULRICE-6442] - Rice Dev: Permission Lookup screen, Permission Template attribute label missing
[KULRICE-6443] - Extra buttons appearing in lookup footer
[KULRICE-6446] - Links in lookup results don't function in IE8
[KULRICE-6449] - Exception when clicking inquiry for role
[KULRICE-6450] - Bug in DataDictionary property descriptor handling in the face of generic and co-variant return trypes
[KULRICE-6451] - Can not create KNS maintenance documents
[KULRICE-6452] - Rename KRMS_CNTXT_TERM_SPEC_PREREQ_S to KRMS_CNTXT_VLD_TERM_SPEC_S
[KULRICE-6453] - Rice Dev: PeopleFlow Maintenance Screen throwing error on Direct Inquiry
[KULRICE-6460] - Component refresh doesn't work after closing a lightbox
[KULRICE-6461] - PeopleFlow member field doesn't get refreshed after the member type changes
[KULRICE-6462] - Progressive render of "All or First Action" field in PeopleFlow member add section is broken
[KULRICE-6469] - Changed needed in DTOConverter.java because ExtensionDefinition does not contain the constructor parameters like the ObjectDefinition does, which causes the attribute to be constructed incorrectly
[KULRICE-6471] - Table sorting is broke again!
[KULRICE-6475] - CacheTarget schema is incorrect
[KULRICE-6477] - Resurrect the concept of a "Default Country" on the "CountryService"
[KULRICE-6478] - KEN- principalId/principalName discrepancy
[KULRICE-6480] - Fix HashMap concurrency issue in org.kuali.rice.krad.UserSession
[KULRICE-6481] - KRIM_ROLE_PERM_T allows for null ROLE_ID/PERM_ID
[KULRICE-6483] - Ad hoc tab styling issues
[KULRICE-6485] - Reorder group no longer displays/works
[KULRICE-6487] - Agenda Copy moves Agenda Items from old agenda to new agenda
[KULRICE-6488] - Term submission causes exception with blank Specification ID field
[KULRICE-6489] - Document Search by "Approver" returns all documents if the principal name passed is not found.
[KULRICE-6493] - RiceDev: Clicking on any doc id from action list or doc search results in 404 error
[KULRICE-6494] - Document search by "Group Viewer" doesn't return correct data
[KULRICE-6501] - Patch OJB such that it unwraps connections and statements for Oracle in such a way that it works with Java Melody, use new JDBC "Wrapper" api for this
[KULRICE-6504] - Potentially strange behavior in how KSB exports services and determines if they are already exported
[KULRICE-6508] - On person Inquiry, the Active Indicator "both" and "no" buttons do not work correctly, only active rows are returned in any situation
[KULRICE-6512] - Rice Dev: Clicking on View Document Configuration gives error
[KULRICE-6513] - DataObjectMetaDataServiceImpl's areNotesSupported method implementation seems to be incorrect
[KULRICE-6521] - After context startup, KSBConfigurer.requeueMessages is being executed before DataDictionary indexing
[KULRICE-6524] - Modifying a parameter twice in a row results in OptimisticLockExceptions in back-end workflow processing on the second document
[KULRICE-6525] - Agenda Inquiry is broken
[KULRICE-6531] - Rice 2.0 Upgrade script 2011-06-17-m6.sql references non-existent column
[KULRICE-6534] - Rename KREW_STYLE_T table to KRCR_STYLE_T, change it's id column to a string, and change StyleContract.getStyleId to StyleContract.getId() returning a String instead of a Long
[KULRICE-6535] - KIM Person Maintenance Page refers to incorrect fields
[KULRICE-6537] - KRIM_PND_GRP_MBR_T table's MBR_NM column should be expanded
[KULRICE-6545] - SendNotificationService in KEN is not annotated properly
[KULRICE-6546] - Rice Dev: eDoc Lite delivered example broken (eDoc.Example1DocType)
[KULRICE-6549] - Display of AuthorizationException messages seems incorrect
[KULRICE-6552] - Term Spec maint doc create new: Category collection doesn't show namespace or name when using "lookup / add multiple..."
[KULRICE-6556] - Rice Dev: Principal ID search on Person lookup is case sensitive
[KULRICE-6558] - Resolve remoting situation for string coercion service used for proposition validation
[KULRICE-6560] - RoleTypeServiceBase's has incorrect check within hasDerivedRole method
[KULRICE-6561] - DataDictionaryValidationService's validateBusinessObject is not functioning properly
[KULRICE-6564] - PDF generation spits out multiple Failed to load image: errors when building DocBook docs
[KULRICE-6566] - Rice Dev: Error thrown when return value from lookup on eDoc Lite
[KULRICE-6571] - KRMS Term Categories allow multiple identical entries
[KULRICE-6572] - KRMS Valid Term Specification to Context Assignments. Allows Duplicate Assignments
[KULRICE-6576] - PeopleFlow Action Id lookup throws NPE
[KULRICE-6577] - KRAD Infrastructure not handling null OJB proxies?
[KULRICE-6582] - Reflection-based toString methods cause problems on business objects
[KULRICE-6586] - Rice Dev: KRMS NPE when trying to edit/create an agenda
[KULRICE-6587] - Document Search Results open in a new window regardless of the system parameter (DOCUMENT_SEARCH_POPUP_IND) value
[KULRICE-6592] - wrong sequence used for an insert in 2011-09-26b.sql upgrade scripts
[KULRICE-6593] - take action button is missing for taking mass actions
[KULRICE-6594] - When creating mail messages, use the actual user to send the email rather than the backdoor user.
[KULRICE-6595] - Problem with Data Dictionary Entry hierarchy for transactional documents
[KULRICE-6599] - Module names passed to module configurers should all be lowercase
[KULRICE-6601] - WorkflowDocumentService not currently getting published on the service bus
[KULRICE-6609] - KSB run mode should default to "remote"
[KULRICE-6610] - if you delete the root proposition in a rule, you get an incident report
[KULRICE-6615] - Quickfinder lookups result in incident reports on return
[KULRICE-6618] - Add abstract="true" to UIF base beans that are associated with abstract classes
[KULRICE-6619] - Role Lookup does not provide link to inquiry
[KULRICE-6620] - Role Inquiry does not contain the information present in Rice 1.x
[KULRICE-6621] - Related keys on collections are not being set on add line
[KULRICE-6622] - "Packet too large" error thrown from inserting into Session document table
[KULRICE-6633] - KualiMaintenanceDocumentAction is modifying the http request parameter map which is not permitted
[KULRICE-6636] - Incorrect KEW service references while running in embedded mode
[KULRICE-6648] - empty input fields with p:required="true" aren't preventing maintenance document submits.
[KULRICE-6649] - DWR setValue method, by default, escapes HTML (in 3.0 M1, RC2 releases); dhtml.js needs modification
[KULRICE-6652] - Lock down (add auth check) to Context, Term Specification, and Term maintenance docs
[KULRICE-6653] - IFrame height adjustment logic leads to JS error in IE8
[KULRICE-6659] - Fix call to isBoNotesEnabled on KNS maintainable
[KULRICE-6660] - KRAD tldheader.jsp contains old KNS tags
[KULRICE-6686] - AdHocRouteRecipients Tab - Person Lookup is incorrectly mapping principalName to AdHocRoutePerson.id
[KULRICE-6687] - Person lookup isn't case-insensitive in Rice 2.0
[KULRICE-6688] - member paging broken on Group & Role inquiry
[KULRICE-6692] - For PeopleFlow actions, returning from lookup for id doesn't populate name
[KULRICE-6695] - Review and fix the proper scenarios under which "approvalPeopleFlowActionTypeService" and "notificationPeopleFlowActionTypeService" are exported and need to be loaded
[KULRICE-6700] - Rice Dev1: Error on Group and Role Inquiry when using Pagination Links
[KULRICE-6701] - KSPD: Research speeding up unmarshalling in base Document Search
[KULRICE-6705] - autoGrowNestedPaths breaking complex field validations
[KULRICE-6709] - Configuring separate add line fields for a collection causes and exception when attempting to add a line
[KULRICE-6710] - Drop krms_cntxt_vld_rule_t, krms_cntxt_vld_actn_t and krms_cntxt_vld_agenda_t tables
[KULRICE-6711] - RoleMemberBo.groovy contains invalid code
[KULRICE-6720] - Clicking Add Proposition throwns NPE in org.kuali.rice.krad.uif.util.ComponentFactory.getNewInstanceForRefresh(ComponentFactory.java:143) origComponent is null
[KULRICE-6734] - NPE First time KRAD Incident Report
[KULRICE-6756] - DocumentSearchCustomizationServiceImpl does not load customizers properly
[KULRICE-6758] - Apply error colors not working for tabs due to syntax error
[KULRICE-6763] - Another instance of incorrect kew service reference in embedded mode
[KULRICE-6767] - Applying of result customizations in DocumentSearchServiceImpl does not work properly
[KULRICE-6768] - Customization of clearing document search criteria does not clear properly if no DocumentSearchCustomizer is defined for a document type
[KULRICE-6770] - Server side required error message from dictionary validation not getting variable replaced
[KULRICE-6772] - ModuleConfigurers should not allow injection of moduleName and validRunModes
[KULRICE-6778] - View header (and page) size doesn't span full width
[KULRICE-6783] - Incorrect service reference to RoutingReportService while running Routing report in embedded mode
[KULRICE-6788] - KSB SOAPFaultException while attempting to insert a BO Note (while running in embedded mode)
[KULRICE-6789] - SOAPFaultException from background EmailQueue processing (while invoking ImmediateEmailReminderQueue.sendReminder method)
[KULRICE-6790] - ClassCastException when background KSB message processing invokes kimCacheAdminService (embedded mode)
[KULRICE-6791] - Term Specification collection members multiply
[KULRICE-6793] - ClassCastException QuickFinder cannot be cast to Field on Create new PeopleFlow PeopleFlow Summary Type selection.
[KULRICE-6794] - KNS field label not being rendered in DD validation messages
[KULRICE-6795] - krad.utility.js error message when adding PeopleFlow Members (in Firefox)
[KULRICE-6797] - Term Spec Multiple Lookups return (single) value doesn't.
[KULRICE-6799] - DOC_STAT_NM length changed from 64 to 20 characters
[KULRICE-6800] - ParamaterRepositoryService throws exception due to null ParameterType
[KULRICE-6803] - Rice Dev: Fix slang that's incorporated into Campus Lookup Screen
[KULRICE-6811] - Conversion of WorkflowFunctions to EDLFunctions is not present in database upgrade scripts
[KULRICE-6812] - ValidationIntegrationTest failing on oracle

Improvement

[KULRICE-112] - Consider moving "performLookup" back into Lookup action class
[KULRICE-1023] - Add support to Document structures for Versionable Documents
[KULRICE-1342] - Create a new type of attribute to replace WorkflowAttribute, make a SOAP remoted version of this service
[KULRICE-2374] - Make sure that all KEW super user actions are available on WorkflowDocument
[KULRICE-3319] - Determine if we need to do some work on the KimTypeService interface to make return types more consistent
[KULRICE-3515] - Performance improvements to creation of ValidActionsDTO
[KULRICE-3722] - Get rid of the need to have the oracle jdbc driver as a dependency in our pom
[KULRICE-3804] - Make 1.1.0 Java 1.6 compliant
[KULRICE-4086] - Remove org.kuali.rice.kns.util.spring.AutoPopulatingList
[KULRICE-4273] - Explosion of Namespace concepts in Rice
[KULRICE-4301] - Improve consistency of service namespaces
[KULRICE-4399] - As a part of the dependency upgrade for 1.1 upgrade Jetty to version 7
[KULRICE-4436] - Classes used in CommonSpringBeans.xml should be in core instead of the KNS
[KULRICE-4451] - Re-examine how RiceApplicationConfigurationService is being used to resolve doc handler urls (and other variables) from across the service bus
[KULRICE-4460] - Replace all references to oracle.jdbc.driver.OracleDriver with oracle.jdbc.OracleDriver
[KULRICE-4529] - Split out service apis out into their own maven module in the Rice project
[KULRICE-4531] - Improve our use of namespaces for KimTypeServices, get rid of deprecated methods on KimCommonUtils
[KULRICE-4555] - Combine SimpleDocumentActionsWebService with WorkflowDocumentActionsService, review and approve the new contract for workflow services
[KULRICE-4582] - Remove deprecated Config.OUT_BOX_DEFAULT_PREFERENCE_ON
[KULRICE-4589] - rename NOTIFY_EXCLUDED_USERS_IND parm to something clearer
[KULRICE-4700] - Fully convert java serialized services to SOAP services
[KULRICE-4788] - Update Servlet API to 2.5, JSP API to 2.1 and test harnesses to launch supporting containers
[KULRICE-4793] - Create a development support module in rice.
[KULRICE-4794] - Change DOC_HDR_ID on KREW_DOC_HDR_T from a numeric type to a character type
[KULRICE-4803] - Add unique constraint on KIM permission namespace:name
[KULRICE-4816] - Implement interaction with the service registry so that it goes over remote connection instead of direct database access
[KULRICE-4838] - Move integration tests into a separate module and improve the way we handle instantiation of test clients in the test harness, take advantage of maven integration-test lifecycle
[KULRICE-4853] - Convert RunMode & Client Protocol to Java 5 enums
[KULRICE-4854] - Create a coherent design for KeyValue pair
[KULRICE-4861] - Remove JSTLConstants class, make Spring contexts web aware
[KULRICE-4863] - Research if we can replace our custom email services (there are multiple!) with the Spring mailer stuff and get rid of duplicate email service implementations
[KULRICE-4866] - Make sure all Constant/Utility classes are final classes (not interfaces) and have private ctors
[KULRICE-4867] - Create SQLUtils class
[KULRICE-4871] - Remove the parameterized type on the PersonService
[KULRICE-4881] - Clean up utility classes
[KULRICE-4888] - Make KualiException Abstract
[KULRICE-4895] - Migrate from XAPool & JOTM to Bitronix connection pool & Transaction Manager
[KULRICE-4946] - Convert Rice to an m2eclipse project
[KULRICE-4947] - Test out Maven 3/Move to Maven 3
[KULRICE-5010] - Improve role-member logic in RoleManagementServiceImpl.removePrincipalFromRole for performance
[KULRICE-5011] - Implement an improved way to delete RELOAD_ACTION_LIST prefs for users
[KULRICE-5014] - Rename kew.bootstrap.spring.file to web.bootstrap.spring.file in StandaloneInitializeListener
[KULRICE-5034] - CXF SOAP service logging does not honor log4j.properties
[KULRICE-5041] - Migrate xml import/export framework to the Rice core
[KULRICE-5101] - Improve messaging for simultaneous workflow actions
[KULRICE-5105] - Populate the error message map when spring PropertyEditors throw validation exceptions
[KULRICE-5114] - Allow config.xml files to include HTTPSessionListeners
[KULRICE-5117] - Clean up current issues with configurers in Rice
[KULRICE-5121] - Remove JsValue from ValidCharactersConstraint
[KULRICE-5131] - Port Exception/Incident reporting to KRAD
[KULRICE-5132] - Implement Breadcrumbs in KRAD
[KULRICE-5133] - Implement suggest boxes
[KULRICE-5134] - Implement AJAX update of fields
[KULRICE-5150] - Default control (if not set) to TextControl
[KULRICE-5155] - Create new ValidCharactersConstraint equivalents of the old ValidationPattern
[KULRICE-5172] - Default the binding path for fieldLookup.fieldConversions
[KULRICE-5179] - Convert KNS Formatters to Spring PropertyEditors for use in KRAD
[KULRICE-5182] - Add property to AttributeField that allows removing the field from the keyboard tab order
[KULRICE-5183] - alternate/additonal DisplayAttributeName implementation not honoring key values finders
[KULRICE-5189] - JAX-WS annotated service methods that return collections need to be annotated appropriately so that empty lists are handled properly
[KULRICE-5191] - Look into KSB integration test failures that are the result of database table locking issues
[KULRICE-5201] - Convert remaining numeric identifiers in KEW database to character-based identifiers
[KULRICE-5207] - Remove all KEW httpInvoker type services from the registry
[KULRICE-5209] - Add servicePath to all of our Kuali Rice services that we are publishing
[KULRICE-5214] - Remove legacy "help" system from KEW
[KULRICE-5252] - Complete BusinessObjectEntry and DataObjectEntry split
[KULRICE-5260] - Implement requiredness validation on nested objects
[KULRICE-5321] - Create test that routes a FiscalOfficerInfo document in the sampleapp
[KULRICE-5325] - Get rid of KualiWorkflowDocument, replace with standard WorkflowDocument KEW api
[KULRICE-5326] - Get rid of KualiWorkflowInfo, replace with usage of standard KEW apis
[KULRICE-5348] - Rename column PREV_RULE_VER_NBR on KREW_RULE_T to PREV_VER_RULE_ID
[KULRICE-5352] - KNS DD doesn't support configuration of ReloadingDataDictionary
[KULRICE-5357] - update our caching solution for rice.
[KULRICE-5379] - align the ParameterService & ConfigService understanding of boolean string values
[KULRICE-5396] - Convert InactivatableFromTo to use joda-time
[KULRICE-5398] - Implement proper thread-safe lazy initialization for WorkflowDocumentFactory
[KULRICE-5431] - Customized Post Data-load Encryption
[KULRICE-5445] - Ensure that _futureElements on data transfer objects are not included in serialized form
[KULRICE-5527] - Need Transaction proxy configured for spring mvc
[KULRICE-5611] - Remove usage of XmlConfiguredAttribute from qualifier resolver and rule attributes
[KULRICE-5618] - Create a Kim permission for the Cache Admin Screen
[KULRICE-5664] - Drop CSTM_ACTN_LIST_ATTRIB_CLS_NM, CSTM_ACTN_EMAIL_ATTRIB_CLS_NM, and CSTM_DOC_NTE_ATTRIB_CLS_NM columns from KREW_DOC_TYP_T
[KULRICE-5670] - Reduce the size of the ACTVN_TYP column on KREW_RTE_NODE_T
[KULRICE-5677] - Add support for getCurrentNodeNames to WorkflowDocument, change method from getActiveNodeInstances to getActiveRouteNodeInstances
[KULRICE-5682] - Remove RouteModuleRemote as it is not used anywhere
[KULRICE-5685] - KEW document type policy to turn off automatic replaying of last nodes for enroute docs when role changes
[KULRICE-5686] - Need the ability to configure results limits differently for different lookups
[KULRICE-5694] - Under some circumstances lookups can return the same row multiple times
[KULRICE-5695] - provide "hours of availability" awareness
[KULRICE-5716] - Allow for type ids to be optional on various KRMS tables
[KULRICE-5719] - Look into changing term map from Map<Term, Object> to Map<String, Object> for engine exec api
[KULRICE-5720] - KIM should be using enums for things like "MemberType" on RoleMembership
[KULRICE-5735] - Find all places where we are using WorkflowAttributeValidationError and switch to RemotableAttrbuteError
[KULRICE-5738] - Modify SearchableAttribute so that when returning RemotableAttributeField objects, it's possible to indicate whether or not the column should be visible
[KULRICE-5747] - Add "documentTypeAttributes" to org.kuali.rice.kew.api.doctype.DocumentType
[KULRICE-5750] - Add "extraDocumentTypeNames" to the document lookup criteria
[KULRICE-5760] - Apply "queue" naming schema to various KEW message queues
[KULRICE-5761] - Create a SOAP version of the MoveDocumentProcessor
[KULRICE-5818] - Add namespace code to component lookup and inquiry
[KULRICE-5821] - Have both a getDocumentHandlerUrl and getResolvedDocumentHandlerUrl on DocumentTypeContract
[KULRICE-5826] - Add validation of RuleAttribute type when ingesting <ruleAttribute> elements
[KULRICE-5830] - Improve the AttachmentServlet security
[KULRICE-5848] - Add a set of preferences for allowing a user to turn off emails for complete, approve, acknowledge, or FYI requests.
[KULRICE-5852] - Modify the display of the contents of a note to preserve the whitespace by default.
[KULRICE-5857] - Add ability to detete Service Registry entries by application id
[KULRICE-5859] - Add a limited size attribute so the page will only show the "refine your results" message when the number of search results exceeds the limited amount
[KULRICE-5865] - When the SuperUser.do page is requested directly the routeHeader is null so change to throw an error with a more helpful message.
[KULRICE-5866] - In ActionRequestFactory.java, instead of passing 0 into a method, change to pass new Integer(0)
[KULRICE-5871] - Moved the div outside of the inquiry link so the anchor doesn't display as a block element to make the text is easier to select
[KULRICE-5916] - toggle selection of rule or proposition when clicked a second time
[KULRICE-5917] - typed in campus code doesn't get pulled into lookup on CampusAgendaType custom attribute
[KULRICE-5920] - ActionListService should be properly annotated as a SOAP service
[KULRICE-5940] - Disable sort on specific column inside of RichTable
[KULRICE-5941] - Determine the proper way to handle client-side caching and eviction operations
[KULRICE-5948] - Make name show for PeopleFlowTypeActionTypeService attribute
[KULRICE-5950] - Action description should be optional
[KULRICE-5951] - In Rule editor, Category selector is not wired up to term
[KULRICE-5953] - Make propositions that are in edit mode easier to select
[KULRICE-5968] - Allow for users to customize their email notification preferences based on the document type
[KULRICE-5973] - Need the ability to mark columns in datatable as invisible
[KULRICE-5975] - Fix field conversion split so that it works with ":" as part of the field key
[KULRICE-5978] - Create new Document Type policy for enroute error suppression
[KULRICE-5980] - Display Server messages/growls that may be a result of an ajax call
[KULRICE-5981] - Breadcrumbs with single page views
[KULRICE-5991] - View/Page Loading fixes - indicator and visual appearance during load
[KULRICE-5994] - ComparisonOperator does not deal with multiple types well, and isn't pluggable
[KULRICE-5996] - Enhance AgendaAuthorizationServiceImpl so that more than one permission can exist for agenda maintenance
[KULRICE-5998] - Create proper KSB impl and KSB web modules
[KULRICE-6003] - Make PeopleFlow type service names friendlier to humans
[KULRICE-6009] - Standardize on use of "derived role" terminology in RoleTypeService instead of "application role" or "dynamic role"
[KULRICE-6042] - Convert documentation from Word files and Doc2Help to Docbook
[KULRICE-6049] - Make the special my.conf params needed for MySQL more apparent in our documentation
[KULRICE-6050] - Create Initial Draft of KRMS and KRAD Chapters in User's Guide and Technical Guide
[KULRICE-6051] - Determine how we can automate documentation builds with doc-to-help
[KULRICE-6052] - Integrate appendix on RESTful services into the main body of the KSB TRG
[KULRICE-6082] - Permission maintenance doc requires Template Id and has no lookup
[KULRICE-6278] - Add NODE or similar context variable to reference the current node being rendered
[KULRICE-6292] - Modify term selection ui so that parameterized terms can be specified
[KULRICE-6293] - add loadAgenda to AgendaTypeService to allow pluggable qualifier matching
[KULRICE-6294] - Validation of proposition constants on add rule
[KULRICE-6295] - Make PeopleFlow collection of stops sort by stop #
[KULRICE-6299] - New DB index to improve action list performance
[KULRICE-6306] - Upgrade Spring version to 3.1.0.RELEASE
[KULRICE-6330] - Set up support for loading of "web" modules last and modify ModuleConfigurer framework to support this
[KULRICE-6336] - Fix issue of multiple datasources and transaction managers being loaded and configured via CommonSpringBeans.xml
[KULRICE-6339] - Remove unused datasource.pool.size config parameter from various files
[KULRICE-6351] - Add ability to disable usage of security for the ServiceRegistry on the client side
[KULRICE-6352] - Upgrade from apache cxf 2.3.6 to 2.3.7
[KULRICE-6354] - The KSB synchronization process calls both getAllServicesForInstance and getAllOnlineServices every 60 seconds but should only need to call getAllOnlineServices
[KULRICE-6362] - Move Mailer api from core-impl up to core-api module and change package appropriately, split Mailer class into Mailer interface and MailerImpl implementation
[KULRICE-6363] - Change name of KEW data source/ojb alias from enWorkflowDataSource to kewDataSource
[KULRICE-6398] - Set up NonSerializableSessionListener so that it defaults to true only when the environment code is "dev"
[KULRICE-6399] - Make configuring the reloading data dictionary easier for client app developers
[KULRICE-6431] - Refactor KRMS context join table names
[KULRICE-6435] - Make it so that Rice 2.0 can shut down cleanly
[KULRICE-6436] - Tune ehcache configuration for the various rice modules
[KULRICE-6438] - Create folder structure for custom, library and modified library js files
[KULRICE-6463] - New DB Indexes for KIM Permission checks
[KULRICE-6470] - Properly javadoc ComponentService
[KULRICE-6474] - Try to come up with a better name than "CacheService"
[KULRICE-6476] - Add ability to get all services by applicationId to the ServiceRegistry
[KULRICE-6484] - SubCollection label needs to allow disclosure mechanism
[KULRICE-6486] - Pull the css.files and js.files property and add Javascript files to the ViewTheme
[KULRICE-6490] - Make it so Doc Search returns documents for Initiators, approvers, and reviewers that are no longer active
[KULRICE-6492] - Return entity information by employeeID even if the person's employee info is inactive or in a historical location
[KULRICE-6509] - Synchronize with remote services on KSB startup
[KULRICE-6511] - Implement ability to load remote services lazily
[KULRICE-6517] - Remove nillable=true from Parameter.java
[KULRICE-6518] - Add a colon between attributes which make up caching key for ParameterKey
[KULRICE-6522] - Add getDefaultNamesForPrincipalId back to the Identity Service
[KULRICE-6523] - Change component used for Module locking parameters to All
[KULRICE-6527] - Switch MDC logging in UserLoginFilter to use principalName instead of principalId
[KULRICE-6528] - Remove KSBConfigSpringBeans.xml, COREConfigSpringBeans.xml, and KRADConfigSpringBeans.xml
[KULRICE-6530] - Add Uif-HorizontalBoxGroup and Uif-HorizontalBoxSection bean options
[KULRICE-6533] - Rename cache service endpoints to "cache admin service" since that's what we renamed the actual service interface to
[KULRICE-6539] - Rename methods in KIM that refer to "ByNameAndNamespaceCode" to "ByNamespaceCodeAndName"
[KULRICE-6543] - Remove PersonService.hasPersonProperty as it's no longer used
[KULRICE-6544] - PermissionService.isAuthorized, hasPermission, getPermissionAssignees, and getAuthorizedPermissions no longer needs to take permission details since permission namespace + name are now unique
[KULRICE-6562] - Pull CampusService (and any other test / sample code that leaked in) out of API
[KULRICE-6596] - Component publishing should probably be turned off by default
[KULRICE-6597] - Make sure abstract and prototype are declared correctly on all beans as necessary
[KULRICE-6607] - Cleanup of logging configuration and remove default logging of SOAP service output
[KULRICE-6612] - Raise the default connection pool size in common-config-defaults.xml
[KULRICE-6613] - There is no API on the role service to remove a permission from a role
[KULRICE-6650] - Don't create NullPointerException on null History copy.
[KULRICE-6655] - Add getRequestedActions (returning a Set<ActionRequestType>) and contains to RequestedActions class
[KULRICE-6656] - Modified WorkflowDocumentService.getDocumentStatus to return DocumentStatus instead of a String
[KULRICE-6657] - Remove getActionsRequested method from WorkflowDocumentService since a similar method is already on WorkflowDocumentActionsService
[KULRICE-6664] - Validation ServerSide for KRAD Views
[KULRICE-6665] - Validation being skipped for some field types on an addLine js call
[KULRICE-6683] - Add a "THIN" client run mode to KEW, KIM, and KSB modules
[KULRICE-6685] - It should not be required to have to set "contextConfigLocation" manually on KSBDispatcherServlet
[KULRICE-6697] - Remove RunModeServiceExporter since it is no longer being used
[KULRICE-6699] - Reduce view size for session storage and form clearling
[KULRICE-6704] - reuse ObjectMapper instance in DocumentSearchInternalUtils for better performance
[KULRICE-6707] - Add additional Maintenance specific bean defs to add hooks to make changes later
[KULRICE-6713] - Added ComponentBase bean for future hooks and default tweaking
[KULRICE-6766] - Create integration tests for DocumentSearchCustomizer
[KULRICE-6773] - Remove rice.additionalSpringFiles from common-config-defaults.xml
[KULRICE-6786] - More helpful error message when object isn't in session than NullPointer from ComponentFactory

New Feature

[KULRICE-3708] - Provide an out-of-the-box LDAP connector for Rice
[KULRICE-4528] - Implement ability for rice server to know what version of a client server they are calling
[KULRICE-5020] - Implement a ComponentService
[KULRICE-5032] - Design and Implement a general-purpose criteria-based api for use on Rice services which need it
[KULRICE-5036] - Develop proposition that works with collections
[KULRICE-5067] - Implement backend support for general-purpose criteria query api
[KULRICE-5068] - Implement ParameterRepositoryService.findParameters
[KULRICE-5130] - Sample Maintenance Document for testing attachments
[KULRICE-5136] - Create Groovy conversion script for updating KNS DD and Document DD to KRAD
[KULRICE-5138] - Add pop up text area option for TextAreas and Text input fields
[KULRICE-5204] - Create rice-kew-api and rice-kew-impl modules
[KULRICE-5208] - Implement KEW caching services as SOAP and allow for them to be easily exported to the Bus that way
[KULRICE-5211] - Implement PreferencesService (KREW_USR_OPTN_T) so that it is accessed remotely instead of via database
[KULRICE-5212] - Implement RuleService, RuleAttributeService, and related such that they are accessed remotely via SOAP instead of via direct database calls to the rule tables
[KULRICE-5230] - Add ability to fetch a service from the ServiceBus by a combination of service name and application id
[KULRICE-5404] - Create model objects for attribute definitions
[KULRICE-5416] - allow for pseudo-buttons with text and images in them
[KULRICE-5561] - enabling features for working with custom remotable attributes
[KULRICE-5563] - Create PeopleFlowActionTypeService
[KULRICE-5574] - Create Agenda Rule
[KULRICE-5592] - Create and implement PeopleFlowService
[KULRICE-5593] - Create PeopleFlowTypeService interface
[KULRICE-5594] - Create KewTypeRepositoryService
[KULRICE-5595] - Create a new KRMS node implementation extending RequestActivationNode
[KULRICE-5596] - Add support to Document Type XML schema to specify the krms integrating route node
[KULRICE-5597] - Write integration tests for KEW integration with KRMS and PeopleFlows
[KULRICE-5671] - Implement support for Priority-Parallel activation in the workflow engine
[KULRICE-5681] - Implement ability for RequestNode to be called multiple times to generate action requests
[KULRICE-5684] - Implement RouteModule which can generate action requests from PeopleFlows
[KULRICE-5697] - Add the ability to parameterize a ValuesFinder
[KULRICE-5709] - Add responsibility id and action request policy to people flow member and delegate data models
[KULRICE-5824] - Added a check to deactivate the action request when it tries to route to an inactive group based on document type policy
[KULRICE-5971] - Add button to add a compound proposition parent to the selected simple proposition
[KULRICE-5995] - ingest updated travel account doctype into master db
[KULRICE-6085] - Add Inquiry View to Agenda
[KULRICE-6282] - AdHoc Route to Completion - MSU Contribution
[KULRICE-6437] - Add ability to use #node on client-bound properties like progressiveRender and refreshWhenChanged

Task

[KULRICE-121] - ID html elements in KNS pages for easier HtmlUnit testing
[KULRICE-1031] - Consolidate and document ServiceLocators and ResourceLoaders
[KULRICE-2677] - Add full entity DTO versions of getEntity methods to IdentityService and IdentityManagementService
[KULRICE-3166] - Determine if we can use joda-time as part of our api instead of built-in java date/time types
[KULRICE-3211] - Upgrade to Spring 3.0.1
[KULRICE-3222] - Ensure that ParameterServerService can be remoted and improve caching in ParameterServiceProxyImpl
[KULRICE-3631] - Remove ActionItem.getRouteHeader() and ActionItem.setRouteHeader(...)
[KULRICE-3793] - Set up all supporting infrastructure for the 1.1 development work
[KULRICE-3819] - Rice access to foundation confluence
[KULRICE-3918] - Sample app BOs extend PersistableBusinessObject but the corresponding table doesn't contain the necessary fields.
[KULRICE-4096] - Remove TypedArrayList, use Spring's AutoPopulatingList in its stead
[KULRICE-4220] - Ensure that Rice is using up-to-date referenced libraries
[KULRICE-4247] - Perform and document modularity analysis on KNS
[KULRICE-4406] - Include mysql / oracle dependencies in "test" modules with provided scope
[KULRICE-4488] - Upgrade Spring schema declarations to 3.0 in spring files.
[KULRICE-4491] - Research Business Rule Engines and GUIs for KC functional equivalence
[KULRICE-4495] - Identify locations where client applications are allowed to connect and use the Rice standalone server database
[KULRICE-4496] - Speed Test: Soap vs java serialization for our remoted services
[KULRICE-4503] - Decide on and document process for how service contracts will be defined and maintained
[KULRICE-4504] - Identify and document all services in Rice that can be invoked remotely
[KULRICE-4505] - Decide on and document guidelines for how service contracts, DTOs, and implementations should be versioned
[KULRICE-4506] - Identity the service components in Rice today which are being remoted through KSB object remoting
[KULRICE-4508] - Decide on and document recommended practices for service governance
[KULRICE-4510] - Decide on and document a standard for service names and namespaces and how they will be affected by versioning
[KULRICE-4511] - Refactor service registry to implement inclusion of version numbers in the service registry
[KULRICE-4512] - Get recommendations from Savoir Technologies on larger architectural efforts that we should consider for our future roadmap
[KULRICE-4625] - Determine proposed breakdown for modules
[KULRICE-4628] - Document modularization
[KULRICE-4632] - Separate development framework from middleware services
[KULRICE-4637] - Remove deprecated code
[KULRICE-4639] - Document modularity changes
[KULRICE-4642] - Remove support for object remoting
[KULRICE-4643] - Re-implement default services as SOAP
[KULRICE-4644] - Annotate services that don't currently support SOAP with jax-ws
[KULRICE-4645] - add maven build step to generate WSDLs
[KULRICE-4646] - Remove direct database calls from client applications to rice db where possible
[KULRICE-4647] - Define service naming and namespace standard for rice services
[KULRICE-4648] - Implement service naming and namespace standard for rice services
[KULRICE-4659] - Figure out how client apps will publish their KimTypeServices (and other modules' callback service) via SOAP
[KULRICE-4660] - Determine WSDL publishing process
[KULRICE-4661] - create mechanism for handling "namespaces" in Spring and avoiding service name conflicts
[KULRICE-4663] - Implement a way to figure out what version of Rice an application is running
[KULRICE-4664] - Implement a mechanism for "newer" Rice server versions to call back into older client service versions
[KULRICE-4666] - Evaluate "remote" KIM services
[KULRICE-4669] - Implement rules engine for kc functional equivalence
[KULRICE-4674] - integrate with KNS business rules
[KULRICE-4703] - Improve current UI/configuration
[KULRICE-4704] - User Interface for KC Workflow
[KULRICE-4717] - More screen flexibility in the development framework and support for transactional documents
[KULRICE-4743] - Migrate to Spring MVC
[KULRICE-4763] - Code a proof of concept reflecting Savoir versioning recommendations
[KULRICE-4764] - docInfo property should be on KualiDocumentFormBase not KualiForm
[KULRICE-4767] - Look into setting tab index for dynamic refreshes
[KULRICE-4784] - Put together a proof-of-concept on version compatibility
[KULRICE-4806] - Update the rice-site url in the main pom.xml file
[KULRICE-4817] - Refactor RiceConfigurer so that is doesn't depend on all the modules
[KULRICE-4824] - move test resources out of main source tree
[KULRICE-4825] - Decouple code so modules can stand alone
[KULRICE-4851] - remove KEW UserSession
[KULRICE-4855] - Refactor SQLBuilder so it does not depend on anything outside rice-core
[KULRICE-4858] - Create krad-app-framework and krad-web-framework modules in Rice 1.1, begin moving classes into them according to modularity refactoring plan
[KULRICE-4864] - remove the dependencies UserSession has on EditablePropertiesHolder, ConfigService, & WorkflowDocument
[KULRICE-4868] - Create war module for our standalone server
[KULRICE-4869] - Random Modularity tasks
[KULRICE-4872] - Implement a conversion utility for Rice 2.0 which will aid in performing conversions on legacy maintainable XML
[KULRICE-4873] - Create Interfaces and Implementation code for new Business Rule model
[KULRICE-4880] - Refactory KimCommonUtils into a public and private piece
[KULRICE-4884] - Remove DateUtils, NumberUtils and corresponding unit tests
[KULRICE-4887] - Update package naming standards document
[KULRICE-4897] - Removal of toStringMapper, toStringBuilder, from BusinessObjectBase
[KULRICE-4898] - Remove org.kuali.rice.kew.web.session.Authentication and calls to it. Replace with KIM permissions.
[KULRICE-4904] - KC needs FAX to be supported as a Phone type
[KULRICE-4905] - Display appropriate icon based on attachment type in Maintenance Documents
[KULRICE-4906] - create jira for some of the Groovy isssues
[KULRICE-4911] - Implement version compatibility unit tests
[KULRICE-4915] - Examples to validate use cases
[KULRICE-4917] - Load test development & implementation
[KULRICE-4924] - Include source and javadoc tarballs with SNAPSHOTS and RELEASES
[KULRICE-4928] - The kr test environments don't appear to be running right now, need to be set back up
[KULRICE-4931] - Execute a review of all libraries and version in Kuali Rice 2.0
[KULRICE-4934] - Verify service endpoint urls for each version
[KULRICE-4963] - Fix ParameterService api so that is can be accessed remotely.
[KULRICE-4965] - Remove Timer class for jira
[KULRICE-4966] - Split KimServiceLocator into api and impl pieces (KimServiceLocatorInternal)
[KULRICE-4967] - Remove dateTimeService parameters from KRNS_PARM_T table
[KULRICE-4975] - ServiceRegistryAction uses KEWServiceLocator to get a datasource
[KULRICE-4978] - Convert services and objects to new model object design
[KULRICE-4987] - Change name of "shareddata" module to "location"
[KULRICE-4988] - Annotate outgoing service calls with client version number
[KULRICE-4989] - Make NamespaceService remotable
[KULRICE-4991] - Remove DOBJ_MAINT_CD_ACTV_IND on krns_cmp_typ_t table
[KULRICE-4992] - Review and rename tables/columns in master database
[KULRICE-5009] - Create tables & BOs needed for propositions
[KULRICE-5017] - remove RiceService & GRLServiceInjectionPostProcessor
[KULRICE-5018] - Figure out how to Handle non-database related "Components"
[KULRICE-5037] - Do analysis on adding parameter map to Asset
[KULRICE-5038] - Create Rule and Action BOs
[KULRICE-5039] - Create rice-krms-test integration test project
[KULRICE-5042] - Apply edoclite-related database and XML updates to master database
[KULRICE-5043] - repackage the core modules for our new packaging standards
[KULRICE-5048] - Write remote tests for shareddata services to exercise SOAP calls of service APIs
[KULRICE-5062] - Extract StyleService from KEW/EDL to core-api
[KULRICE-5065] - Implement parent pom on Rice trunk
[KULRICE-5066] - Move KRAD Test environment from KRAD branch to trunk
[KULRICE-5070] - Handle ObjectIds on new Model Objects
[KULRICE-5074] - Create KRMS Agenda Repository BO
[KULRICE-5075] - Create KRMS Context BO
[KULRICE-5076] - Create KRMS Repository Asset and Asset Resolver BOs
[KULRICE-5079] - Create KRMS Repository Term / Term Resolver Bos
[KULRICE-5084] - Update the Rice 2.0.0 Master Database to include KRMS Data Model
[KULRICE-5085] - Refactor Asset & AssetResolver to use Term vocabulary and to better fit with data model
[KULRICE-5088] - Need to be able to retrieve States based on Alternate Country Code
[KULRICE-5090] - Come up with a proposal for data inactivation in KRMS repository
[KULRICE-5091] - Ensure that all developers are using the same set of code formatting standards
[KULRICE-5094] - Create Term-related contracts, model objects, BOs and services
[KULRICE-5095] - Make sure converted BO/DTOs are using more generic names for fields (i.e. stop using the class in the field names)
[KULRICE-5098] - Create krms module configuration
[KULRICE-5102] - Add table connecting Context and Rule in DB, and update the model to reflect this relationship
[KULRICE-5103] - Refactor rice.krms.api.repository to make sub-packages
[KULRICE-5104] - Move rice-krms-test to rice/test/krms
[KULRICE-5107] - Demote TermResolutionException to a RuntimeException, and improve the exception message
[KULRICE-5111] - add integration test that uses rice-krms-impl's BO services to write entities to the DB
[KULRICE-5115] - Remove unused EDL modules and move EDL-web to EDL-impl
[KULRICE-5116] - Combine web and impl modules
[KULRICE-5123] - Create krms agenda & rule editor skeleton
[KULRICE-5124] - Tomcat 7 fixes for rice 2.0
[KULRICE-5126] - Convert bookstore sample application to rice 2.0
[KULRICE-5128] - Services are being created with ServiceNamespaceURI = "KEW" when they are defined in spring file as ""
[KULRICE-5129] - Update Rice to Groovy 1.8
[KULRICE-5139] - tip to tail repository backed rule execution integration test
[KULRICE-5141] - Add methods to Proposition interface to allow for navigating nested Propositions
[KULRICE-5143] - Figure out what other applications are doing about requiring css and js to exist in external portal windows
[KULRICE-5145] - Add web.xml files to sampleapp and standalone so web.bootstrap.spring.file is defaulted (but can be overridden)
[KULRICE-5153] - Implement AdHoc Recipients tag for documents
[KULRICE-5154] - adding qualifier checking to ResponsibilityServiceImpl
[KULRICE-5156] - Validate client side flag on view not being looked at for client side validation
[KULRICE-5157] - Update Group objects to use new Attributes class instead of AttributeSet
[KULRICE-5158] - Update Group service to use new Criteria API
[KULRICE-5160] - CompoundProposition needs to log its results
[KULRICE-5164] - Add instructional text property to AttributeDefinition and AttributeField and render now in the UI where the summary field currently is
[KULRICE-5165] - Upgrade jQuery version to 1.6
[KULRICE-5167] - Create KRMS Function BOs.
[KULRICE-5168] - Handle Context Attributes BOs in ContextBoService
[KULRICE-5169] - Consistent KRMS entity attributes
[KULRICE-5174] - merge RepositoryCreateAndExecuteIntegrationTest and RuleRepositoryIntegrationTest
[KULRICE-5176] - Allow add line to be different layout than existing lines for table layout (needed for KIM conversion)
[KULRICE-5177] - UIF Framework - Add support for creating AttributeField components with code (needed for KEW conversion)
[KULRICE-5180] - engine results reflect proposition tree
[KULRICE-5181] - DataTable should skip add row during column sorting
[KULRICE-5186] - build DataObjectEntry and LookupView for RuleBo
[KULRICE-5187] - implement category for repository terms and propositions
[KULRICE-5197] - Need to be able to sort by column header like on lookups when editing large roles and groups
[KULRICE-5202] - Active Indicator on KRMS entities
[KULRICE-5203] - Apply pending krms ddl changes
[KULRICE-5205] - Apply table create scripts to the master database
[KULRICE-5206] - Create test for multiple attachments in trunk
[KULRICE-5210] - Refector WorkflowUtility (and how it's used by WorkflowInfo) so that it uses proper techniques for SOAP remoting
[KULRICE-5215] - Remove "RIA" tables from KEW database
[KULRICE-5216] - Remove "Remove/Replace" tables from KEW database
[KULRICE-5219] - Convert ImmediateEmailService to a remotable SOAP service
[KULRICE-5220] - Convert CustomActionListAttribute to a remotable SOAP service
[KULRICE-5223] - Modify WorkflowAttributeXmlValidator so that it's not possible to execute remotely
[KULRICE-5224] - Convert RuleValidationAttribute to a remotable SOAP service
[KULRICE-5225] - Convert {KEW}ResponsibilityChangeService to a remotable SOAP service
[KULRICE-5226] - Convert {KEW}RuleCacheProcessorService to a remotable SOAP service
[KULRICE-5227] - Convert {KEW}RuleDelegationCacheProcessorService to a remotable SOAP service
[KULRICE-5228] - Convert {KEW}WorkgroupMembershipChangeService to a remotable SOAP service
[KULRICE-5229] - Convert KIM role, permission, and responsibility "type" services in KEW to their SOAP remoted form
[KULRICE-5231] - General cleanup and verification tasks for KEW version compatibility refactoring
[KULRICE-5232] - Move containerTreeNode.tag into the krad folder
[KULRICE-5234] - POM Cleanup
[KULRICE-5238] - build agenda tree UI components
[KULRICE-5245] - Fix context selection so that it can query on multiple attributes
[KULRICE-5246] - Add hidden property names property to AttributeField
[KULRICE-5247] - Implement User Control and Workgroup Control
[KULRICE-5254] - AttributeField have to support html escape
[KULRICE-5255] - Implement export functionality in KRAD inquiry
[KULRICE-5258] - translate old criteria map to new criteria api
[KULRICE-5259] - Maintenance Docs - Finish document notes tab
[KULRICE-5282] - Uif Framework - Binding needs to look at forceUppercase
[KULRICE-5288] - Move the 'show blank qualifier' kim toggle from a Config param to a System param?
[KULRICE-5291] - KualiHelpAction in kns module has dependency on DocSearchCriteriaDTO
[KULRICE-5292] - Having two Inactivatable interfaces is a little confusing, can we rename the core version?
[KULRICE-5297] - Troubleshoot pulling context id value into agenda quickfinder/lookup automatically
[KULRICE-5298] - Configure agenda editor's context and agenda lookups to do lookaheads
[KULRICE-5303] - document or fix redundancies in KeyValue class
[KULRICE-5309] - KRMS Rule Maintenance Screen
[KULRICE-5311] - Create lookup & inquiry DD for TermBo and TermSpecificationBo
[KULRICE-5316] - Turn off KCB by default
[KULRICE-5318] - move IdentityManagementService interface/impl to client-contrib
[KULRICE-5319] - Implement caching on remote soap services
[KULRICE-5320] - create a migration script to make permission names/resp names unique
[KULRICE-5323] - Dataset Consolidation
[KULRICE-5332] - UIF Framework - Issue with Ajax calls and displaying incident report
[KULRICE-5335] - Database Changes for Category
[KULRICE-5336] - Correct random failures of remote tests on CI
[KULRICE-5339] - Finish integration with presentation controller/authorizer/AttributeSecurity checking KIM
[KULRICE-5342] - Develop add rule functionality
[KULRICE-5343] - Create additional unit tests for KIM
[KULRICE-5344] - remove Attributes & AttributeSet class replace with Map<String, String>
[KULRICE-5351] - Change KRMS Results to use a Map instead of a String
[KULRICE-5358] - Implement cut & paste in agenda editor
[KULRICE-5359] - Ensure that there is a unique constraint for the combo of nm and nmspc_cd where applicable in the KRMS schema
[KULRICE-5360] - Rename kim fields to more closely align with PESC standard
[KULRICE-5369] - Combine Group and GroupUpate services
[KULRICE-5373] - Issues from lightbox code review
[KULRICE-5374] - Uif Framework - Sync state of client to server
[KULRICE-5375] - Uif Framework - Exposing server variables in JS
[KULRICE-5376] - Uif Framework - Refactor conditional expressions for non String fields
[KULRICE-5380] - remove Timestamp from immutable *Member objects and replace with DateTime
[KULRICE-5381] - Include detailed version information
[KULRICE-5383] - Issues/work for ValidCharacterConstraints
[KULRICE-5384] - Error message and Error highlight for select controls and the mustOccurs constraint need fixes
[KULRICE-5401] - Loading indicator doesn't show when doing a search in lightbox or returning a value from lightbox
[KULRICE-5412] - Create unit tests for ValidCharactersConstraint subclasses and spring beans
[KULRICE-5413] - figure out how to handle collections being null on model objects when being unmarshalled
[KULRICE-5414] - App title not getting set in HTML window title
[KULRICE-5417] - Get createproject.groovy working for Rice 2.0
[KULRICE-5419] - add description to Context, Term, Term Spec, and KRMS Attribute Definition at DB, BO, model object, builder, and interface layers
[KULRICE-5443] - Remove non-soap kim services
[KULRICE-5444] - Fix Kim service namespaces
[KULRICE-5453] - Get the Agenda Editor submit working
[KULRICE-5455] - clean up action data model
[KULRICE-5483] - Module Service not returning correct Inquiry/Lookup URLs for KRAD
[KULRICE-5492] - Create PeopleFlow database tables and BOs
[KULRICE-5506] - All of our kim services need to have proper exception handling, return immutable collections, do not return null
[KULRICE-5530] - Address large white space at top of each view
[KULRICE-5533] - Accordian headers should be surrounded by <a> tag, and have arrow icon as a background image
[KULRICE-5534] - "Click me" button needs class "ui-corner-all" (Kitchen sink > UI components)
[KULRICE-5535] - date picker width should be 36em
[KULRICE-5536] - Wire up KRMS services in KRMSSpringBeans.xml
[KULRICE-5537] - Make edit & copy links for agenda lookup open the agenda editor
[KULRICE-5538] - make agenda editor maintenance doc submittable & persistable
[KULRICE-5539] - Add custom attributes to the agenda editor
[KULRICE-5540] - make rule editor maintenance doc submittable & persistable
[KULRICE-5542] - Develop action configuration portion of rule editor
[KULRICE-5546] - Implement 'add proposition' and 'edit proposition' features on the rule editor
[KULRICE-5551] - KRAD: collections need css hooks so that we can style them
[KULRICE-5559] - Add hook (or use existing hook) for custom "Create New" links in lookups
[KULRICE-5565] - Add support to EngineResults to support a general-purpose Hash Map of results
[KULRICE-5569] - KRAD: Conditional Refresh: Overlay loading message isn't aligned
[KULRICE-5573] - KRAD: Test View 1: Checkbox and Radio labels should display differently than field grouping labels
[KULRICE-5589] - Rename TypeContract and Type classes in Kim to CodedAttributeContract and CodedAttribute
[KULRICE-5590] - Create integration tests for LDAP connector
[KULRICE-5600] - Uif Framework: Change Formatter property on AttributeField to PropertyEditor
[KULRICE-5602] - Selenium Smoke Test Creation: Identity Create Documents Tests
[KULRICE-5603] - Selenium Smoke Test Creation: Identity Maintenance Documents Tests
[KULRICE-5604] - Selenium Smoke Test Creation: Configuration Create Documents Tests
[KULRICE-5605] - Selenium Smoke Test Creation: Configuration Maintenance Documents Tests
[KULRICE-5606] - Selenium Smoke Test Creation: Workflow Create Documents Tests
[KULRICE-5607] - Selenium Smoke Test Creation: Workflow Maintenance Documents Tests
[KULRICE-5608] - Selenium Smoke Test Creation: Main Menu Create Documents Tests
[KULRICE-5609] - Selenium Smoke Test Creation: Main Menu Maintenance Documents Tests
[KULRICE-5610] - Selenium Smoke Test Creation: More Complex Create-Blanket Approve Documents Tests
[KULRICE-5612] - Check in selenium tests to rice-sampleapp module
[KULRICE-5625] - Create permission templates for create, modify, view agenda
[KULRICE-5626] - implement UI for selecting Term in proposition from amongst those that are available in the current Context
[KULRICE-5627] - Implement creation/selection of parameterized Term for proposition UI
[KULRICE-5628] - Implement operator selection in proposition editor UI
[KULRICE-5630] - Make sure Document Search is working with ranged searches
[KULRICE-5632] - Implement KewModuleService so that document and document type ebos are loaded through remote services
[KULRICE-5633] - Make sure Detailed Search save/restore works for Document Search
[KULRICE-5634] - Annotate ExtensionRespositoryService
[KULRICE-5635] - Re-enable Application Document Status code for Doc Search
[KULRICE-5636] - Fix problems with document search saved searches
[KULRICE-5638] - Figure out how to make caching possible for services in the core module
[KULRICE-5644] - Selenium Smoke Test Creation: Even More Complex Create-Blanket Approve Documents Tests
[KULRICE-5645] - Update Kim service update methods where there are collections in object graph
[KULRICE-5648] - Export appropriate KRMS services onto the bus
[KULRICE-5650] - Add ability to specify PeopleFlows on RequestsNode
[KULRICE-5658] - Soap-ify KEN and KCB
[KULRICE-5659] - Modularize Spring files
[KULRICE-5662] - Update PeopleFlow data model diagram to reference recent changes
[KULRICE-5665] - Implement the ability to run rice sample app as a seperate application integrated with the Rice Standalone Server, put process in place to automatically deploy to a test environment using CI
[KULRICE-5666] - Integrate KRMS with KNS for validation rules
[KULRICE-5668] - Make Context Maintenance document maintainable
[KULRICE-5674] - Add configuration parameter to set whether NonSerializableSessionListener listener is enabled or not. Default to false for production environment.
[KULRICE-5701] - Review JAX-WS service methods that return collections
[KULRICE-5704] - Convert RouteDocumentMessageService to a soap service and publish it under a consistent name
[KULRICE-5708] - Move only partially realized impl and framework modules back into the catchall "impl" module
[KULRICE-5710] - Develop PeopleFlow lookup, inquiry, and maintenance document
[KULRICE-5721] - Remove requirement to specify EVENT in agenda selection criteria
[KULRICE-5723] - Make sure that we validate that everything within an agenda is valid within that agenda's context
[KULRICE-5734] - Rename "DocumentSearchSecurityFilterAttribute" to "DocumentSecurityAttribute" for the rule attribute type name
[KULRICE-5739] - Fix commented out document search tests
[KULRICE-5740] - Verify that super user document search is working properly after the doc search framework refactoring
[KULRICE-5742] - Ensure that all document search-related services have their wsdls generated in pom.xml
[KULRICE-5746] - Replace use of "Document Lookup" with "Document Search" in the codebase
[KULRICE-5749] - Need to reconcile various workflow document dates (STAT_MDFN_DT, RTE_STAT_MDFN_DT, RTE_LVL_MDFN_DT, and APP_DOC_STAT_MDFN_DT)
[KULRICE-5753] - Make sure that max results and start index are implemented properly from the DocumentLookupCriteria.
[KULRICE-5756] - Search for all instances of "TODO - Rice 2.0" in source code and ensure that all issues are addressed or at least represented in jira
[KULRICE-5757] - Update any parameter detail components in the database that are called DocSearchCriteriaDTO and change them to DocumentSearch instead
[KULRICE-5762] - Convert riceApplicationConfigurationService to a SOAP service
[KULRICE-5763] - Create new test environment so that we can have the last two milestones available as well at the latest
[KULRICE-5771] - Change @Cacheable annotation keys to use parameter numbers instead of parameter names
[KULRICE-5775] - CriteriaLookupService sometimes uses the wrong datasource for lookups
[KULRICE-5783] - Enable caching for ParameterRepositoryService
[KULRICE-5784] - Group, Role, and Principal update methods need to call "inactivate" methods when their "active" status is changed to inactive
[KULRICE-5787] - Changes to remotable fields
[KULRICE-5788] - Kill 'api' module.
[KULRICE-5808] - Fix cache errors when injecting service containing cache annotations with spring
[KULRICE-5820] - Determine if we want to drop the "Soap" from the end of our service names
[KULRICE-5822] - Make RemoteFieldsHolder so it can be used as a collection
[KULRICE-5833] - Dev config that mimics the env4 + env5 config from KULRICE-5665 for developers
[KULRICE-5844] - Add rule type selection and custom attribute UI to rule editor
[KULRICE-5849] - 404 error for ui-bg_flat_75_ffffff_40x100.png
[KULRICE-5872] - Apply Database Changes for Rule Action Attributes and Ingest Context Document Type
[KULRICE-5873] - Apply Database changes for Rule and Action Validation sub-types
[KULRICE-5881] - Radiobuttons for Rule and Action subtypes labels and buttons touch.
[KULRICE-5934] - Proposition Summary displays "null", when a new proposition is created using the KRMS Rule Editor
[KULRICE-5937] - Add javadocs to WorkflowDocument and WorkflowDocumentFactory
[KULRICE-5942] - See if we can improve our cache flushing with new Spring cache annotations
[KULRICE-5946] - Implement 'copy rule' functionality
[KULRICE-5958] - Bump Bitronix to version 2.1.2
[KULRICE-5966] - update ehcache configurations to set cache's to expire
[KULRICE-5967] - Investigate whether we should publish methods on services to flush caches
[KULRICE-5992] - Create KRAD portal tab for KRAD test links
[KULRICE-6016] - Clean up release notes & docbook docs for beta
[KULRICE-6019] - Update Database Upgrade information in Release Notes
[KULRICE-6020] - Affirm strategy for XML namespacing on Rice services
[KULRICE-6021] - Identify and document where the Rice standalone server can make calls back into client applications
[KULRICE-6023] - Convert content in RiceHelp.zip to DocBook
[KULRICE-6025] - Document the addition of the new "Priority-Parallel" activation type in KEW
[KULRICE-6026] - Update Database Diagrams in Rice documentation
[KULRICE-6027] - Document the dropping of support for Tomcat 5.5 (servlet spec 2.4/jsp 2.0)
[KULRICE-6041] - Update documentation stating that we are now 1.6 compliant for both source and compile
[KULRICE-6058] - Upgrade Guide for 2.0: Expand Content and Finalize
[KULRICE-6060] - Review & update installation guide for Rice 2.0
[KULRICE-6061] - Create JavaDocs for KRMS
[KULRICE-6068] - User's Guide: Review & Update KEW Chapter
[KULRICE-6074] - Technical Guide: Review & Update KEW Chapter
[KULRICE-6078] - Create Skeleton of Client Developer's Guide
[KULRICE-6084] - Create & expand Features Guide in DocBook
[KULRICE-6089] - Once feature for fine-grained action list notification preferences is implemented in core Rice, add documentation to user guide and online help for the feature
[KULRICE-6092] - Create Accessibility Status Report for 2.0
[KULRICE-6097] - Selenium Smoke Test Creation: KRMS Basic Edit Functions
[KULRICE-6277] - Apply Database changes for PeopleFlow Action Name
[KULRICE-6287] - Enable KEN integration tests
[KULRICE-6303] - Apply KRMS Master Database changes - compound proposition sequence number mods.
[KULRICE-6314] - Type Inconsistency in MaintenanceDocumentBase causing exceptions
[KULRICE-6316] - Apply Database changes for Validation Type fixes
[KULRICE-6329] - Remove KRAD tab from standalone
[KULRICE-6331] - Move LDAP module under KIM
[KULRICE-6332] - help.tag hasn't been updated from 1.0.3.x code base for trunk
[KULRICE-6343] - XpathQualifierResolver bugs
[KULRICE-6360] - Remove RunMode.THIN and other traces of legacy "THIN" mode as it is no longer needed
[KULRICE-6373] - Update KRAD doctype to HTML5
[KULRICE-6378] - Document Search not working with document types with searchable attributes
[KULRICE-6379] - Rename remote interfaces so they don't have the same name as the UIF components
[KULRICE-6380] - Remove InquiryNoResultView and build logic into main view
[KULRICE-6413] - Remove BusAdminService and ability to "update" pool settings from the "Thread Pool" user interface as it's functionality is currently problematic
[KULRICE-6425] - Notification Search link does not populate document type name for search
[KULRICE-6428] - IntrospectionException - Type mismatch between read and write methods
[KULRICE-6432] - Apply Database changes for Proposition validation
[KULRICE-6445] - KrmsTypeAttribute needs to be versioned.
[KULRICE-6464] - KNS L&F: Header styling needs fixed
[KULRICE-6465] - KNS L&F: Document header has alignment problems
[KULRICE-6466] - KNS L&F: Breadcrumbs lost styling
[KULRICE-6468] - KNS L&F: Disclosure headers are doing a red underline on hover
[KULRICE-6496] - Remove css files from kns directory that we are not using
[KULRICE-6497] - Change constant used in moduleLocked.jsp to be in KRADConstants instead of KualiAction
[KULRICE-6498] - Create custom maintainables where needed for cache flushing.
[KULRICE-6499] - Add permission for CacheAdmin screen
[KULRICE-6500] - Group document shows stacktrace instead of correctly handling validation errors
[KULRICE-6502] - Requiredness is not enforced
[KULRICE-6514] - Upgrade to "spring-security-cas" version 3.1.0.RELEASE
[KULRICE-6516] - Document client applications requirements on what they need to do in order to ensure they remain compatible with future versions of Kuali Rice
[KULRICE-6529] - Incident report should default to Classic style as that is what KRMS uses
[KULRICE-6536] - Coordinate review of all Rice 2.0 apis
[KULRICE-6538] - Fix delimiters in Oracle upgrade scripts
[KULRICE-6547] - Create New Role seems to be setting KimType to default value, even if other kim type selected
[KULRICE-6551] - Add KRMS doc types to scripts/upgrades
[KULRICE-6559] - People Flow Edit: exception thrown when adding / deleting delegates to people flow members
[KULRICE-6565] - Fix qualifiers on role for Person and Role Documents
[KULRICE-6578] - Make it so the standalone server will start up without having to specify the web.bootstrap.spring.file parameter
[KULRICE-6579] - Rice: KSPD work on SoapUI
[KULRICE-6581] - Rice: KSPD List of Manual Testing Of KSB tasks
[KULRICE-6598] - Remove password from principal dto.
[KULRICE-6600] - Rice 2.0 upgrade scripts coming with KIM bootstrap data need to be consistent w.r.t ID generation
[KULRICE-6605] - KSPD: Work on Http request logger
[KULRICE-6606] - KSPD: Hookup JavaMelody/Spring
[KULRICE-6635] - Do something about duplication of processCollectionAddLine in ViewHelperServiceImpl and PeopleFlowMaintainableImpl
[KULRICE-6662] - Apply sql for permission to the Term,TermSpecification and Context to master DB
[KULRICE-6682] - add caching to internal DocumentTypeService
[KULRICE-6684] - Rename KRAD Jsp for application view
[KULRICE-6689] - Replace string concatenation with StringBuilder.append when rejoining with commas in DocumentSearchServiceImpl.saveSearch
[KULRICE-6690] - Verify we are exporting proper KimTypeService implementations as well as embedding appropriate ones
[KULRICE-6693] - Add documentation on CallbackServiceExporter to the technical documentation for KIM
[KULRICE-6694] - Determine if KRMS Type Services can be properly exported to the service bus and used remotely
[KULRICE-6703] - Change WorkflowRuleAttribute validate methods to return List<? extends RemotableAttributeErrorContract>
[KULRICE-6712] - Problem with radio groups in htmlControlAttribute
[KULRICE-6714] - change assign* methods in RoleService to not throw RiceIllegalStateException when rolemember already exists
[KULRICE-6715] - create groovy folders to core-service modules to allow it to compile in eclipse
[KULRICE-6716] - Add javax.servlet dependency to location module
[KULRICE-6722] - RoleService assign methods don't check for inactive role members correctly
[KULRICE-6723] - ResponsibilityService *ByTemplate methods not handling responsibility details correctly
[KULRICE-6733] - convert permission bo objects from groovy to java to test performance difference
[KULRICE-6755] - Fix ExceptionRetryCountTest
[KULRICE-6759] - Add manual flush method on the IdentityArchiveService.
[KULRICE-6774] - Add information to install guide about how to run createproject.groovy to set up a client application
[KULRICE-6792] - Person Lookup not working in KIM embedded mode
[KULRICE-6801] - TO_DATE sql function stripped from doc search sql for 'like', 'not like', and 'not equal'