Free time to software for linux

Network Time Tools (NTT) is a set of network tools designed to provide monitoring of a network and the services on that network, and provide various reports on the hosts/services and optional alerts via email, pager, and cellphones. It also has the capability to send messages on user-specified services to email, pagers and cell phones.
Main features:
- Bandwidth measurement based on time intervals
- Checks Service availibilty on specified Hosts for the following protocols:
- ftp
- ssh
- telnet
- dns
- http ( specific pages )
- www ( simple head )
- pop
- nntp
- imap
- irc
- smtp
- Ability to send alerts based on user specified services to:
- pagers
- cell phones
- email
- A frontend that displays a daily report that can be viewed by a web browser or cell phone.
- views specific servers
- views specific services
- views bandwidth measurements
- view alerts
- Data stored in a Mysql Database
- Easily configurable via an XML config file
- Runs in Daemon or one-shot mode

Time Sheets are free linux timesheets for project tracking.
Automate Project management, Billing and Payroll with your Free Web Employee Timesheets! Use your Free Web Timesheets to Discover secret profits in your business and ease billing now.
Automate Payroll with improved setup features. 100% web-based Linux Employee Timesheets program.
Main features:
User Interface
- Complete redesign including user-friendly organization and navigation
- Collapsible, customizable Toolbar with interactive calendar and timesheet status data
- Scrolling and single day display options for long periods that alleviate "wide" timesheet and compliance problems
- Dynamic, on-screen options to sort and display data in a variety of formats
Administrator Interface
- Ability to copy settings from existing users, projects, etc. for quick creation and set up of new items
- Access to all set up options on a single user or project creation screen
- Various types of reports consolidated and accessible under the main Reports tab
- Improved search, select and assign capabilities for automated approval plans, etc.
- Ability to search for, select and submit multiple timesheets for approval with a single click
- Improved Help menus and Sitemap that act as guides to the new navigation
Look and Feel
- Hierarchical tab navigation with the option to customize the color scheme
- Standard icons and page layout throughout the product
- Continued flexibility for branding and customizing the interface to fit organizational needs
Miscellaneous
- Leave request automation with supervisor review
- Manager reporting on all outstanding time off scheduled
- Option to subtotal by several different parameters in reports
- International character support
- Performance improvements via setting to limit number of items displayed in dropdown menus
- Advanced options for editing approved timesheets to meet specific auditing requirements

TimeTracker is an application loosely based on TimeKeeper, a Windows application used to track the time you spent on a task.

Being a Linux user and not willing to install Wine, I decided to hack my own version.

Time::Zone is a miscellaneous timezone manipulations routines.

SYNOPSIS

use Time::Zone;
print tz2zone();
print tz2zone($ENV{TZ});
print tz2zone($ENV{TZ}, time());
print tz2zone($ENV{TZ}, undef, $isdst);
$offset = tz_local_offset();
$offset = tz_offset($TZ);

This is a collection of miscellaneous timezone manipulation routines.
tz2zone() parses the TZ environment variable and returns a timezone string suitable for inclusion in date-like output. It opionally takes a timezone string, a time, and a is-dst flag.

tz_local_offset() determins the offset from GMT time in seconds. It only does the calculation once.

tz_offset() determines the offset from GMT in seconds of a specified timezone.
tz_name() determines the name of the timezone based on its offset

Time::Piece is a Perl module that contains Object Oriented time objects.

SYNOPSIS

use Time::Piece;

my $t = localtime;
print "Time is $tn";
print "Year is ", $t->year, "n";

This module replaces the standard localtime and gmtime functions with implementations that return objects. It does so in a backwards compatible manner, so that using localtime/gmtime in the way documented in perlfunc will still return what you expect.

The module actually implements most of an interface described by Larry Wall on the perl5-porters mailing list here: http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2000-01/msg00241.html

USAGE

After importing this module, when you use localtime or gmtime in a scalar context, rather than getting an ordinary scalar string representing the date and time, you get a Time::Piece object, whose stringification happens to produce the same effect as the localtime and gmtime functions. There is also a new() constructor provided, which is the same as localtime(), except when passed a Time::Piece object, in which case its a copy constructor. The following methods are available on the object:

$t->sec # also available as $t->second
$t->min # also available as $t->minute
$t->hour # 24 hour
$t->mday # also available as $t->day_of_month
$t->mon # 1 = January
$t->_mon # 0 = January
$t->monname # Feb
$t->month # same as $t->monname
$t->fullmonth # February
$t->year # based at 0 (year 0 AD is, of course 1 BC)
$t->_year # year minus 1900
$t->yy # 2 digit year
$t->wday # 1 = Sunday
$t->_wday # 0 = Sunday
$t->day_of_week # 0 = Sunday
$t->wdayname # Tue
$t->day # same as wdayname
$t->fullday # Tuesday
$t->yday # also available as $t->day_of_year, 0 = Jan 01
$t->isdst # also available as $t->daylight_savings

$t->hms # 12:34:56
$t->hms(".") # 12.34.56
$t->time # same as $t->hms

$t->ymd # 2000-02-29
$t->date # same as $t->ymd
$t->mdy # 02-29-2000
$t->mdy("/") # 02/29/2000
$t->dmy # 29-02-2000
$t->dmy(".") # 29.02.2000
$t->datetime # 2000-02-29T12:34:56 (ISO 8601)
$t->cdate # Tue Feb 29 12:34:56 2000
"$t" # same as $t->cdate

$t->epoch # seconds since the epoch
$t->tzoffset # timezone offset in a Time::Seconds object

$t->julian_day # number of days since Julian period began
$t->mjd # modified Julian date (JD-2400000.5 days)

$t->week # week number (ISO 8601)

$t->is_leap_year # true if it its
$t->month_last_day # 28-31

$t->time_separator($s) # set the default separator (default ":")
$t->date_separator($s) # set the default separator (default "-")
$t->day_list(@days) # set the default weekdays
$t->mon_list(@days) # set the default months

$t->strftime(FORMAT) # same as POSIX::strftime (without the overhead
# of the full POSIX extension)
$t->strftime() # "Tue, 29 Feb 2000 12:34:56 GMT"

Time::Piece->strptime(STRING, FORMAT)
# see strptime man page. Creates a new
# Time::Piece object

Ruby Time Tracker is a stable and complete time tracking system for small businesses that invoice for time spent by several employees on many projects.

Future Plans

Planned upgrades include:

Locking down past periods so that no entries can be made or changed after invoicing
Custom periods so that users may define billing cycles for thier company
Reminders sent to employees who have not made entries daily or at the end of a billing cycle

Two Versions

There are currently two versions in development. The professional version uses a MySQL database and requires some knowlege of installing and configuring Ruby on Rails applications to install. The lite version includes an installer that will install and configure an SQLight database and a webrick web server for easy installation. Development is being done on the professional version and periodically the lite version will be updated to include new functionality.

Time::Format is a Perl module for easy-to-use date/time formatting.

SYNOPSIS

use Time::Format qw(%time %strftime %manip);

$time{$format}
$time{$format, $unixtime}

print "Today is $time{yyyy/mm/dd}n";
print "Yesterday was $time{yyyy/mm/dd, time-24*60*60}n";
print "The time is $time{hh:mm:ss}n";
print "Another time is $time{H:mm am tz, $another_time}n";
print "Timestamp: $time{yyyymmdd.hhmmss.mmm}n";
%time also accepts Date::Manip strings and DateTime objects:
$dm = Date::Manip::ParseDate(last monday);
print "Last monday was $time{Month d, yyyy, $dm}";
$dt = DateTime->new (....);
print "Heres another date: $time{m/d/yy, $dt}";
It also accepts most ISO-8601 date/time strings:
$t = 2005/10/31T17:11:09; # date separator: / or - or .
$t = 2005-10-31 17.11.09; # in-between separator: T or _ or space
$t = 20051031_171109; # time separator: : or .
$t = 20051031171109; # separators may be omitted
$t = 2005/10/31; # date-only is okay
$t = 17:11:09; # time-only is okay
# But not:
$t = 20051031; # date-only without separators
$t = 171109; # time-only without separators
# ...because those look like epoch time numbers.
%strftime works like POSIXs strftime, if you like those %-formats.
$strftime{$format}
$strftime{$format, $unixtime}
$strftime{$format, $sec,$min,$hour, $mday,$mon,$year, $wday,$yday,$isdst}

print "POSIXish: $strftime{%A, %B %d, %Y, 0,0,0,12,11,95,2}n";
print "POSIXish: $strftime{%A, %B %d, %Y, 1054866251}n";
print "POSIXish: $strftime{%A, %B %d, %Y}n"; # current time
%manip works like Date::Manips UnixDate function.
$manip{$format};
$manip{$format, $when};

print "Date::Manip: $manip{%m/%d/%Y}n"; # current time
print "Date::Manip: $manip{%m/%d/%Y,last Tuesday}n";
These can also be used as standalone functions:
use Time::Format qw(time_format time_strftime time_manip);

print "Today is ", time_format(yyyy/mm/dd, $some_time), "n";
print "POSIXish: ", time_strftime(%A %B %d, %Y,$some_time), "n";
print "Date::Manip: ", time_manip(%m/%d/%Y,$some_time), "n";

This module creates global pseudovariables which format dates and times, according to formatting codes you pass to them in strings.

The %time formatting codes are designed to be easy to remember and use, and to take up just as many characters as the output time value whenever possible. For example, the four-digit year code is "yyyy", the three-letter month abbreviation is "Mon".

The nice thing about having a variable-like interface instead of function calls is that the values can be used inside of strings (as well as outside of strings in ordinary expressions). Dates are frequently used within strings (log messages, output, data records, etc.), so having the ability to interpolate them directly is handy.

Perl allows arbitrary expressions within curly braces of a hash, even when that hash is being interpolated into a string. This allows you to do computations on the fly while formatting times and inserting them into strings. See the "yesterday" example above.

The format strings are designed with programmers in mind. What do you need most frequently? 4-digit year, month, day, 24-based hour, minute, second -- usually with leading zeroes. These six are the easiest formats to use and remember in Time::Format: yyyy, mm, dd, hh, mm, ss. Variants on these formats follow a simple and consistent formula. This module is for everyone who is weary of trying to remember strftime(3)s arcane codes, or of endlessly writing $t[4]++; $t[5]+=1900 as you manually format times or dates.

Note that mm (and related codes) are used both for months and minutes. This is a feature. %time resolves the ambiguity by examining other nearby formatting codes. If its in the context of a year or a day, "month" is assumed. If in the context of an hour or a second, "minute" is assumed.

The format strings are not meant to encompass every date/time need ever conceived. But how often do you need the day of the year (strftimes %j) or the week number (strftimes %W)?

For capabilities that %time does not provide, %strftime provides an interface to POSIXs strftime, and %manip provides an interface to the Date::Manip modules UnixDate function.

If the companion module Time::Format_XS is also installed, Time::Format will detect and use it. This will result in a significant speed increase for %time and time_format.