MightyCal is a powerful calendar/schedule building program which aims
to be the MS Access (tm) of the Web calendaring world. It provides
an easy-to-use administration interface
for developing custom calendars of many types, from simple event bulletin boards, to schedulers
of human/physical resource
availability, to schedulers which automatically take programmed actions. Users of a
MightyCal site can choose to view calendars in a wide variety of formats on numerous
devices, from standard HTML to PDF and WML.
MightyCal's architecture combines the object-oriented
web development of Zope with the XML
transformation capabilities of Cocoon. There are two
portions to the application: the Zope backend, which is
implemented as a Python Product for Zope, and the Cocoon frontend,
which is implemented as a Tomcat web application. The backend
holds the Event data itself, and provides the administrative interface
for constructing and maintaining Calendars. The Cocoon frontend is
responsible for the display of calendars in the user's chosen format.
A powerful template language
and stylesheet editor provides
the administrator the ability to develop calendar views that
automatically display in all available output formats without the need
to write code for each format.
March 6, 2003: Upload of Beta 2
code to Sourceforge. Includes better installation instructions.
March 1, 2003: Addition of a test suite based on HttpUnit, the unit-testing
tool based on Junit. The testing suite is integrated into the
Frontend via the Ant tool; running the "test" target will cause the
tests to be run.
February 4, 2003: Refactoring of Frontend and Backend in
preparation for upcoming Beta 2 release. Highlights of revisions
include new security infrastructure for Backend, the ability to filter
Events based on named Criterion objects, a reworking of the Frontend to
correspond to recommended Cocoon application structure (along with a
radically simplified Sitemap), new Ant project management/building for
the Frontend, and the ability for the Frontend to authenticate its web
users against the Backend.
February 3, 2003: New Screenshots
section! Now featuring screenshots of the Administration Interface
for Calendars and MightyCal Instances.
November 19, 2002: Major refactoring done to the MightyCal
internal structure. Also, an entirely new data entry methodology
has been implemented: the DataEntryTransaction. The
DataEntryTransaction has for its purpose the ability to provide a
multi-stage event editing process, in particular the ability to return
the user to editing an Event when the user's original entries/edits
failed validation tests. When the user is returned to the data
entry screen on a failed validation, the data entry screen will have
full, informative error messages for each invalid field. This new
DataEntryTransaction structure is user-agent agnostic... it will work
whether the user is entering data via the Cocoon frontend, or whether
the administrator is entering an event via the ZMI (Zope Management
Interface). A user can also choose to "Save these values as
defaults", so that future Event creation sessions for the same EventType
will automatically be filled in using the values from the previous
transaction.
November 1, 2002: New Portal-like Administrative interfaces
for individual Calendars are functioning. Currently only a few
panels are available for adding to the interface, but eventually the
calendar Admin will be able to choose from a wide variety of status
panels to add to the interface, in order to create a single-screen
overview of the current happenings in their Calendar.
For older news, see the main Sourceforge News page
Status
The Zope backend now provides the following capabilities:
A basic administrative interface for defining EventTypes and
entering/editing Events
Support for Events which contain fields of BasicContentType
only... that means basic String fields, DateTime fields, Integer fields
and Boolean fields
An integrated ZCatalog that keeps up-to-date indexes about all
Events entered into the MightyCal instance, providing very speedy
searches.
The ability to restructure EventTypes and have the changes
apply to all current Events of that EventType.
Admins can create Calendar objects, which allow for publishing
event sets under an easy to remember URL.
Admins can customize the look-and-feel templates for their
calendars. These templates are now written in an HTML-like
"Intermediate" language, which can easily be transformed into PDF,
HTML or other destination formats by the Cocoon frontend. Also,
admins can tweak the details of look and feel by using CSS to style
the result documents that the user will see.
Admins now have a unified interface for editing Intermediate
Templates, which allows them to drill down into child templates
(wherever they might be in the actual Zope object tree) and edit them,
using an Explorer-like tree view. A similar interface exists for
editing stylesheets.
Calendars provide Event sets in XML format, usable by the
Cocoon frontend for transforming to destination formats.
The Cocoon frontend is working, and happily (and speedily)
generates HTML and PDF read-only calendars based on the XML & XSLT
provided by the backend. The resulting documents are dynamically
styled using style info provided by the Zope backend. An
event-entry interface is mostly built, although it's not activated in
the current Beta 2 release. It needs some work to make it
cooperate with the new backend XMLRPC communication protocols.
To-Dos
Create more (and better) XSLT templates for producing read-only
and read-write calendar views via the Cocoon frontend.
Give users the ability to create their own custom "personal
calendars," along with some control over the look-and-feel of their
calendar pages.
Also visit the Backend's ToDo.txt file
and the Frontend's ToDo.txt file
Project Architecture
The MightyCal calendaring system has four main features that will
distinguish it from other calendar webapps.
Custom calendar building. The Zope drop-in Product
will create a webapp with an administration interface, that will allow
the Administrator to build custom calendars. A custom calendar
consists of a set of event types defined by the administrator, along
with (customizable) "Intermediate-Language" templates for producing the
calendar displays that users will see. Thus, an events calendar
could be defined as holding Meetings, Lectures, Holidays, and Sports
Events, each of which has its own set of fields. The administrator
would be able to customize the display templates using CSS, to "skin"
the site in a way appropriate to the users of the site.
Advanced Field Types. In addition to the usual field
types (e.g. string, integer, date, etc), MightyCal defined Action fields
and Non-Shareable Resource fields. Action fields have Python (or
Perl) code associated with them that gets executed at a specified time
relative to the time that the Event occurs. Actions can include
such things as emailing people who have signed up for a meeting, or
issuing commands to hardware devices (for instance, starting a
webcast for a lecture). Non-Shareable Resource fields allow the
calendar admin to define "resources" that cannot be used by two
parties during the time that the event is going on. Thus,
defining an event for a particular time creates a "lock" on the
resource. Examples of resources might be rooms, computers,
rentable videos, people, or webcasting cameras. Thus, a
MightyCal instance can easily host room schedulers, personal
calendars, or device controllers.
Multiple Display Formats. The Zope backend of
MightyCal generates an intermediate form of XML, a so-called "widget
language", that gets transformed by XSLT into a destination display
format. Apache Cocoon is used as the XSLT transformation
engine, because it supports a vast array of formats, such as HTML,
RDF, WML, VoiceXML, SVG, PDF, RTF and plain text. The XSLT is
also stored in the Zope backend, where an administrator can edit it
in order to support more destination formats, or else customize the
standard XSLT templates. The combination of Zope and Cocoon
(i.e. Python and Java) mean that a very hefty server is required to
run the entire system, or else the Zope backend should be run on a
separate server from the Cocoon frontend.
Extensive User Customizability. MightyCal will
include support for "registered users" who can build their own "virtual
calendars", by defining criteria for events that will appear in them.
Also, users can request notifications of events. Finally,
MightyCal will export RSS/RDF files that can be plugged into other
portals to provide "My Calendar" applets.
