Introduction

Features

This section details features in Case Threads which have already been implemented.

Client and Matter Management

Clients and Matters are core data elements of Case Threads. It is from these informational foundations that all functionality in the application extend.

Clients, which are more generically referred to in Case Threads as Entities, have a powerful and flexible grouping capability allowing users to essentially label their Entities for simple and immediate access. In addition to grouping, it is possible to identify relationships among various Entities with a customizable Relationship Manager.

Time Management

Tracking the time spent and the type of work done during that spent time is a critical function of Case Threads. Case Threads has a rule-driven Time Tracking Module, which enables users to manage multiple timed tasks. Users apply this time to existing Matters and commit a timed record to the database once they have ensured accuracy.

The Time Tracking Module is rule-driven in the sense that the task descriptors available to the user for categorizing the time spent are encoded in modifiable business rules. Rules may specify the type of tasks that are available based on the individual user, the groups the he or she may belong to, the type of Matter, the day of the week or any other identifiable data element. There are a lot of possibilities!

Document Management

Case Threads currently includes a simple File Management Module. At this time, a file of any type (Microsoft Word, Microsoft Excel, images, text files, etc.) may be uploaded to the File Repository. These files are typically tied to individual Matters. Files are stored securely in the database, making it a single central location for all company files. This feature will continue to be extended.

Security

Like many parts of Case Threads, the security framework is rule-driven. That essentially means that the basis for security has the potential to be tied to nearly any identifiable data in the system. The rules for security may be driven by the group to which a user belongs, the individual user, a day of the week or some other time-based entity, or an individual piece of data such as a Matter.

The framework allows for very fine-grain security. It is currently possible to protect:

• System Modules
• System Functions
• Individual Data Fields

This feature will continue to be extended.

Auditing

Case Threads is very good at keeping track of which user is changing what data. It can be configured to capture every single insert, update, or delete occurring in the database. For each capture, it will log which user performed the operation, the time of the operation and an instance of the changed data.

Custom Fields

Custom Fields allow a company to define specific attributes that may exist only in their business domain. Case Threads has taken the concept of Custom Fields and turned it into one of the most powerful aspects of the software.

Most software, from any industry, that touts a Custom Fields function usually allows a set number of empty fields that a user may tie their own labels to. This type of design, which is designed to improve the flexibility of the software, really doesn't provide much function. Some of the problems include:

• Lack of data integrity;
• Insufficient number of fields to support a business need;
• Lack of support for lists of data.

Case Threads solves these problems and many others by providing a truly flexibile and extensible Custom Fields function referred to as Properties. In most cases, Properties in Case Threads, will always be used, because Case Threads only provides the barest minimum of data fields to support Entity and Matter functions. Case Threads was designed to be generic so that it could fit into any business environment with simple (or complex) adaptation.

Entities and Matters are currently the only data elements that implement Properties. Properties are implemented through a scripted rule-driven, sytem, which essentially means that they have the same power as the other features in the system that implement rules. The Properties for an individual Matter or Entity can be based on the individual user, a group of users, a particular type of Matter, or any other identifiable piece of data.

For example, a Matter of type "Criminal" may have a different set of fields than a Matter of type "Domestic".

The fields within Properties use strong data typing. In other words, numbers are stored as numbers and characters are stored as characters, alleviating data integrity issues. There is no limit to the number of fields that can be added. Properties also supports more complex data types such as lists and other custom data.

From a data entry perspective, Properties can support dropdown boxes and other types of pick-lists. In addition, it is possible to used masked edit fields and other complex user interface components.

Properties support input validation at a micro and macro level. In other words, data may be validated against itself or the group for scenarios where mutual exclusion is required.

It is even possible to interact with data outside of Case Threads through Properties! The Properties function in Case Threads will be continually extended.

top

Screenshots

A collage of Case Threads functionality.

top