Free tasks software for linux

Tasks project is a simple to do list application that uses libecal, part of Embedded Evolution Data Server.

Is part of o-hands PIM suite.

Java::Build::Tasks is a Perl module that collects common Java build tasks in one place: jar, jarsigner, etc.

SYNOPSIS

use Java::Build::Tasks;

set_logger($log_object);

copy_file(source, dest);
copy_file(list, of, sources, dest);
copy_file(-r, list, of, sources, with, flags, dest);
copy_file([ list, of, sources ], dest);
copy_file([ -r, list, of, sources, with, flags ], dest);

my $file_list = build_file_list(
BASE_DIR => where/to/start,
EXCLUDE_PATTERNS => [ qr/leave/, qr/these/, qr/out/ ],
INCLUDE_PATTERNS => [ qr/.*include/, qr/these.*/ ],
EXCLUDE_DEFAULTS => 1,
STRIP_BASE_DIR => 1,
QUOTE_DOLLARS => 1,
);

jar(
JAR_FILE => some/full/path/ending/in/a.jar,
FILE_LIST => $file_list;
MANIFEST => location/of/manifest/to/put/in/jar,
BASE_DIR => path/to/change/to/before/building/jar,
APPEND => 1,
);

signjar(
JAR_FILE => what/to/sign,
KEYSTORE => path/to/your/keystore,
ALIAS => $your_alias,
STOREPASS => $your_keystore_pass,
);

my $config_hash = read_prop_file($prop_file_name);

update_prop_file(
NAME => /optional/path/and/file.properties,
NEW_PROPS => %values_to_add_or_update,
);

filter_file(
INPUT => t/file1,
OUTPUT => t/file2,
FILTERS => [
sub { my $string = shift; $string =~ s/Happy/Joyous/g; $_;}
],
);

my $dirties = what_needs_compiling(
SOURCE_FILE_LIST => $list,
SOURCE_DIR => path/to/your/source/files,
DEST_DIR => path/to/your/compiled/files,
SOURCE_TO_COMPILIED_NAME => sub { ... },
);

my $classpath = make_jar_classpath(
DIRS => [ /path/to/some/set/of/jars,
/path/to/some/other/jars ],
INCLUDE_PATTERNS => [ qr/.jar$/, qr/.ZIP$/ ], # optional
);

purge_dirs($base_dir, qw(sub directories to remove));

Taskjitsu tracks tasks from inception to completion, and allows users to report the amount of time spent on each project and task. Taskjitsu satisfies the needs of software development companies, consulting firms, and other organizations that need both flexible time and task tracking. It can generate billing summaries and payroll reports usable with any accounting system.
The system has been in production since 1997; its extensive features have been honed to allow the greatest possible ease in entering and editing data. It offers multiple options for configuring and customizing an installation to support the needs of diverse organizations.
Main features:
Portal View
- Once logged in, users are greeted by a customizable portal page, which provides the following information:
- How many hours theyve worked in the current pay period
- How long its been since they updated their timesheet
- How much leave they have
- How many tasks they have open, broken down into
- Those due soon / of high priority
- Those assigned recently
- Those ready or not to be tested
- Those with new notes.
- From there users can open a task timer, update the status of a task, or add a new note, as well as view all their open tasks, view all tasks, view all tasks assigned to another user, etc.
- Task View
Task Tracking
- Various permission levels: regular user with limited permissions, manager-level user with advanced permissions, and admin-level user with full permissions
- Global functions: add a task, view all tasks, view all open tasks, view single task
- Single task functions: edit task description, edit status, edit assignees, add / edit notes, start task timer
- Task timer: opens in a popup window, has a start / stop button, ability to have multiple timers open and running, option to save to timesheet
- Task roundup: lists the users open tasks in order to perform a batch status and note update (perhaps a weekly team activity to keep all members informed)
- Timesheet review: for admin users only, lists all timesheets for each pay period for review and approval
- Leave editor: for admin users only, add / remove / approve leave for all users
- Email notification: applicable users are notified when any aspect of the task is changed
- Timesheet View
Time Accounting
- Fields for task ID, project, activity, description, and start timer button
- Default view is the current timesheet, but users can edit all previous timesheets
- Popup windows for task, project, and activity lookup
- Option to view timesheets for other users, but only admins can edit other users timesheets
- Billing Report: lists hours worked, total billing, and (optionally) estimated cost per project.
- Payroll summary: lists number of hours worked, hours of leave taken, remaining, and accrued, per user per pay period
- Leave accrual can vary according to the employment status of your staff
- Productivity report: lists hours worked per project / activity per user, viewable only by managers
- Email notification: users are notified when admins add / edit leave
- Maintenance View
Maintenance
- Viewable only by admins
- Add / edit customers, projects, activities, users, and pay periods
- Set system defaults
Enhancements:
- This release includes a fix for a serious, remotely exploitable SQL injection flaw.
- All users should upgrade as soon as possible.
- This release also includes improved error reporting and more robust database connection handling.
- It is possible to change the status of task 48 in Taskjitsu.

ChessTask project is a tool for generating chess tasks.

ChessTask is a frontend for easily creating chess tasks with LaTeX. The tasks are stored in a list which can be exported, either into a LaTeX input file, or into HTML files.

Tess is a C++ library that helps automate final assembly of tedious graphic design tasks (e.g. from photoshop or gimp), such as conjuring piles of web page-specific navigation features.

The project can composite an arbitrary stack of RGBA images, draw antialiased TrueType text (via FreeType), and generate a few shapes and effects. It groks PPM and PAM files, and includes a Perl binding.

multitask allows Python programs to use generators (aka coroutines) to perform cooperative multitasking and asynchronous I/O. Applications written using multitask consist of a set of cooperating tasks that yield to a shared task manager whenever they perform a (potentially) blocking operation, such as I/O on a socket or getting data from a queue.

The task manager temporarily suspends the task (allowing other tasks to run in the meantime) and then restarts it when the blocking operation is complete. Such an approach is suitable for applications that would otherwise have to use select() and/or multiple threads to achieve concurrency.

This project is free software, distributed under the MIT license.

Examples:

As a very simple example, heres how one could use multitask to allow two unrelated tasks to run concurrently:

>>> def printer(message):
... while True:
... print message
... yield
...
>>> multitask.add(printer(hello))
>>> multitask.add(printer(goodbye))
>>> multitask.run()
hello
goodbye
hello
goodbye
hello
goodbye
[and so on ...]

For a more useful example, heres how one could implement a multitasking server that can handle multiple concurrent client connections:

def listener(sock):
while True:
conn, address = (yield multitask.accept(sock))
multitask.add(client_handler(conn))

def client_handler(sock):
while True:
request = (yield multitask.recv(sock, 1024))
if not request:
break
response = handle_request(request)
yield multitask.send(sock, response)

multitask.add(listener(sock))
multitask.run()

The functions and classes in the multitask module allow tasks to yield for I/O operations on sockets and file descriptors, adding/removing data to/from queues, or sleeping for a specified interval. When yielding, a task can also specify a timeout. If the operation for which the task yielded has not completed after the given number of seconds, the task is restarted, and a Timeout exception is raised at the point of yielding.

Tasks can also yield other tasks, which allows for composition of tasks and reuse of existing multitasking code. A child task runs until it either completes or raises an exception, and its output or exception is propagated to its parent. For example:

>>> def parent():
... try:
... print good child says: %s % (yield child())
... print bad child says: %s % (yield child(bad=True))
... except Exception, e:
... print caught exception: %s % e
...
>>> def child(bad=False):
... if bad:
... raise RuntimeError(oops!)
... yield Hi, Mom!
...
>>> multitask.add(parent())
>>> multitask.run()
good child says: Hi, Mom!
caught exception: oops!

Ant SVK Task is a software that can create fully functional support for the SVK SCM tool within Ant build files.
If you like to use SVK in relation with Ant you can use the library you have available which means you have to add the antsvk-Revision.jar to your CLASSPATH.
After that you have to define the different Task which can be used in Ant files later.
To define the svk checkout command you have to put the following Task definition into your Ant build file:
< taskdef name="svkCheckout" classname="com.soebes.antsvk.cli.command.CheckoutCommand" classpath="..."/ >
Enhancements:
- The complete test suite is now working with local repositories and mirrors which will be used by the test suite instead of real repositories.
- Trac is now used as the project management tool. Minor bugfixes were done.