Free cold case software for linux

Kumula Cases is a case management software for lawyers (similar to programs like Amicus Attorney or RA-Micro), based upon the Kumula package. It was part of my diploma thesis and consists of multiple parts:

Cases:

The main application for handling the case files. It shows active and closed case files, and also the appointments and time limits of all cases. When opening a case file, it starts "CaseData", which is merely an "internal" application.

CaseData

Displays the content of one case file. Because of splitting the case management and the case contents, its possible to:

- work with different cases at the same time
- open a case from Cases and Clients (see below)
- open a case directly from your desktop (if you create a shortcut there)
This case content program is also modular and brings the following modules with it:
- Header, for storing reference number, case title etc.
- Parties, for managing clients, contrahents and third parties
- Events, for recording appointments, time limits and resubmissions
- Documents, for assigning letters and other documents to a case file
- Journal, for register revenues and expenses related to a case

Cases module for Clients

This module for Kumulas client management program shows the cases in which a client is involved, including the possibility to open the case file directly.

Unicode::Escape is a Perl module with escape and unescape Unicode characters other than ASCII.

SYNOPSIS

# Escape Unicode charactors like u3042u3043u3044.
# JSON thinks No more Garble!!

# case 1
use Unicode::Escape;
my $escaped1 = Unicode::Escape::escape($str1, euc-jp); # $str1 contains charactor that is not ASCII. $str1 is encoded by euc-jp.
my $escaped2 = Unicode::Escape::escape($str2); # default is utf8 # $str2 contains charactor that is not ASCII.
my $unescaped1 = Unicode::Escape::unescape($str3, shiftjis); # $str3 contains escaped Unicode character. return value is encoded by shiftjis.
my $unescaped2 = Unicode::Escape::unescape($str4); # default is utf8 # $str4 contains escaped Unicode character.

# case 2
use Unicode::Escape qw(escape unescape);
my $escaped1 = escape($str1, euc-jp); # $str1 contains charactor that is not ASCII. $str1 is encoded by euc-jp.
my $escaped2 = escape($str2); # default is utf8 # $str2 contains charactor that is not ASCII.
my $unescaped1 = unescape($str3, shiftjis); # $str3 contains escaped Unicode character. return value is encoded by shiftjis.
my $unescaped2 = unescape($str4); # default is utf8 # $str4 contains escaped Unicode character.

# case 3
use Unicode::Escape;
my $escaper = Unicode::Escape->new($str, shiftjis); # $str contains charactor that is not ASCII. $str is encoded by shiftjis.(default is utf8)
my $escaped = $escaper->escape;

# case 4
use Unicode::Escape;
my $escaper = Unicode::Escape->new($str); # $str contains escaped Unicode character.
my $unescaped1 = $escaper->unescape(shiftjis);
my $unescaped2 = $escaper->unescape; # default is utf8.

Escape and unescape Unicode characters other than ASCII. When the server response is javascript code, it is convenient.

CLASS HIERARCHY

Hash::Case
is a Tie::StdHash
is a Tie::Hash

SYNOPSIS

use Hash::Case::Lower;
tie my(%lchash), Hash::Case::Lower;
$lchash{StraNGeKeY} = 3;
print keys %lchash; # strangekey

Hash::Case is the base class for various classes which tie special treatment for the casing of keys. Be aware of the differences in implementation: Lower and Upper are tied native hashes: these hashes have no need for hidden fields or other assisting data structured. A case Preserve hash will actually create three hashes.

The following strategies are implemented:

Hash::Case::Lower (native hash)

Keys are always considered lower case. The internals of this module translate any incoming key to lower case before it is used.

Hash::Case::Upper (native hash)

Like the ::Lower, but then all keys are always translated into upper case. This module can be of use for some databases, which do translate everything to capitals as well. To avoid confusion, you may want to have you own internal Perl hash do this as well.

Hash::Case::Preserve

The actual casing is ignored, but not forgotten.

METHODS

tie HASH, TIE, [VALUES,] OPTIONS

Tie the HASH with the TIE package which extends Hash::Case. The OPTIONS differ per implementation: read the manual page for the package you actually use. The VALUES is a reference to an array containing key-value pairs, or a reference to a hash: they fill the initial hash.

Examples:

my %x;
tie %x, Hash::Case::Lower;
$x{Upper} = 3;
print keys %x; # upper

my @y = (ABC => 3, DeF => 4);
tie %x, Hash::Case::Lower, @y;
print keys %x; # abc def

my %z = (ABC => 3, DeF => 4);
tie %x, Hash::Case::Lower, %z;
addPairs PAIRS

Specify an even length list of alternating key and value to be stored in the hash.

addHashData HASH

Add the data of a hash (passed as reference) to the created tied hash. The existing values in the hash remain, the keys are adapted to the needs of the the casing.

setHash HASH

The functionality differs for native and wrapper hashes. For native hashes, this is the same as first clearing the hash, and then a call to addHashData. Wrapper hashes will use the hash you specify here to store the data, and re-create the mapping hash.

Bio::ClusterI module is a cluster Perl interface.

SYNOPSIS

# see the implementations of this interface for details but # basically
my $cluster= $cluster->new(-description=>"POLYUBIQUITIN",
-members =>[$seq1,$seq2]);
my @members = $cluster->get_members();
my @sub_members = $cluster->get_members(-species=>"homo sapiens");

This interface is the basic structure for a cluster of bioperl objects. In this case it is up to the implementer to check arguments and initialize whatever new object the implementing class is designed for.

Convert::Morse is a package to convert between ASCII text and MORSE alphabet.
SYNOPSIS
use Convert::Morse qw(as_ascii as_morse is_morsable);
print as_ascii(.... . .-.. .-.. --- -- --- .-. ... .),"n";
# Helo Morse
print as_morse(Perl?),"n"; # .--. . .-. .-.. ..--..
print "Yes!n" if is_morsable(Helo Perl.); # print "Yes!"
This module lets you convert between normal ASCII text and international Morse code. You can redefine the token sets, if you like.
INPUT
ASCII text can have both lower and upper case, it will be converted to upper case prior to converting.
Morse code input consists of dashes - and dots .. The elements MUST NOT to have spaces between, e.g. A is .- and not . -. Characters MUST have at least one space between. Additonal spaces are left over to indicate word boundaries. This means .- -... means AB and and .- -... means A B.
The conversion routines are designed to be stable and ignore/skip unknown input, so that you can write:
print as_ascii(Hello -- --- .-. ... . Perl!);
beware, though, a single . or - at the end will be interpreted as . respective - and thus become E or T. Use Convert::Morse::error() to check wether all went ok or not.
OUTPUT
The output will always consist of upper case letters or, in case of as_morse(), of [-. ].
ERRORS
Unknown tokens in the input are ignored/skipped. In these cases you get the last error message with Convert::Morse::error().
Version restrictions:
- Can not yet do Japanese code nor German Umlaute.

Testitool is an application written in PHP that allows its users to compose and manage QA test plans.
Main features:
Test Plan Management
- Use Testitool to compose rich test plans containing an unlimited number of test cases. Each test case can be mapped to a functional requirement (documented elsewhere), can be assigned a type (e.g. regression, functional, etc.), and more.
Manage Individual Instances of Each Test Plan
- Each test plan contains the master list of all test cases for a given product. However, for any given release you may not want to execute each and every test case. Testitool allows you to pick and choose which test case you will want to execute for any given instance of the test plan. Then track the pass and fail rate of each test plan instance.
Generate Reports
- Testitool allows anyone to view a variety of different test plan reports including: a bug report, a progress report, and failure rate report, and more.
Import/Export Test Cases from Excel
- Do you prefer to use a program like Excel to write your test plans - Testitool allows users to easily import and export test plans and all of their test cases to and from CSV file formats.

Xautolock monitors console activity under the X window system, and fires up a program of your choice if nothing happens during a user configurable period of time.

You can use this to automatically start up a screen locker in case you tend to forget to do so manually before having a coffee break.