Apogée Project

[Note: this text is taken from the official eclipse's proposal]

Introduction

The Apogee Project is a proposed open source project under the Eclipse Technology Project.

This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process document) and is written to declare its intent and scope. This proposal is written to solicit additional participation and input from the Eclipse community. You are invited to comment on and/or join the project. Please send all feedback to the eclipse.technology.apogee newsgroup.

Background

This project comes from our thought about next steps in the Enterprise Content Management (ECM) market. More and more customers need specific application related to ECM to properly handle their data and integrate in a seamless way all their digital assets and involved processes. These applications share a lot of features and need many common services. ECM applications developers definitely need a framework that would ease the creation of this kind of desktop applications, when the browser is not enough...

Eclipse RCP is expected to play a major role for next generation desktop applications. In the ECM business, web interfaces are great, but some customers / applications need more (highly responsive interface, rich UI, desktop integration, offline mode support, etc.).

At Nuxeo, we already have delivered some projects in this area and have begun to create such a framework for ECM applications, called Apogee. It's time to take it to the next level.

This project aims at building a framework to create ECM-oriented desktop applications, independent from vendor or technologies. This framework could be used to create applications that will be integrated with Documentum , Interwoven , Nuxeo CPS or any ECM platform.

Scope

This project's goals are to :

• Define generic concepts and models required to create ECM desktop applications (documents, content types, storage, communication, standards, workflow, search, synchronisation, online/offline, etc.).
• Build the core infrastructure needed by desktop ECM applications, implementing the concepts and models defined above.
• Build a set of highly-customizable application-level components that would ease the creation of ECM desktop applications (mail client, IM, forms, calendar client, document editor, etc.).

Description

This project is divided into 2 area: 

• Core Platform: offers the low level document management infrastructure
• Application Platform: a set of highly extensible applicative components

Core Platform

• A generic resource model (document / container) capable to be integrated with Eclipse resouce model (using it directly or using adapters between both model). The Eclipse resource model seems to be interesting since we can now store resources in other stores than the local filesystem.
• A generic model of "content repository" (given that an application can have to handle several repositories). JSR-170 would be nice to have in the future.
• A generic model to define actions / views available on a document, integrated with the ECM platform (edit, check-in, check-out, properties, etc.) actions model. Actions have to be integrated with Eclipse's menuitems / views model.
• A pluggable unified security model based on roles/permissions that can be easily integrated with the ECM platform (on the server). We are currently investigating ETF/Higgins and Acegi for this part.
• A generic storage model for content. It would be based on the new Eclipse Filesystem (org.eclipse.core.filesystem) to provide the storage infrastructure. The first storage implementation (filesystem adapter for EFS) may be based on db4o or Hibernate + Derby.
• A pluggable indexing and search service for content indexing/searching, based on Lucene.
• A relation service to handle relation between resources (RDF based). This component may be based on Sesame or db4o.
• A generic communication service that can be used by components to communicate with the ECM platform and other component of the information system. This component would likely be based on ECF and XMPP / SOAP) / XML-RPC.
• A generic subscription-based user notification mechanism (to allow the user to be notified by the ECM platform through various channels like XMPP/Jabber, email or SMS, when events occur.
• A form services (based on XForms) to define content creation/edition forms, user interface forms (like workflow action forms), etc. that would be directly delivered by the ECM platform. This service can generate Eclipse Forms / SWT from the XForms description.
• A model to handle online/offline mode (enabling/disabling actions/capabilities).
• A digital signature service to sign documents and workflow actions.
• A deployment service to allow client configuration from server definition (enabling/disabling features, modify client parameters, configuration policy, etc.).

Application Platform

• Mail client component that can be used to create a specific, business-oriented, mail client (for example : custom mail-based application like workflow-based collaborative mail management or CRM application).
• Calendar component (customizable to create calendar-style application like planning management).
• Instant Messaging component (presence and synchronous communication between users, user notification channel).
• Rich document editor (based on XHTML) that can be used to create custom content editors (for example a custom NewsML document editor or a DocBook one).
• Collaborative workspaces (that would offer access to collaborative workspaces on the ECM platform).
• Synchronous document editing (plugged into the document editor).
• Annotation service (that may be based on Annotea).
• Tagging and categorization service.
• Reporting service (BIRT based) to allow the creation of activity reports.

Existing standards and projects leveraged

This project will be based on many high-quality open source framework:

• Eclipse RCP (application infrastructure, UI facilities, Perspectives)
• Eclipse ECF to handle client/server communication, IM and communication needs
• Eclipse WTP/WST to handle web services (XSD and SOAP/WSDL support)
• Eclipse GEF to handle graphic-based user interfaces (relation visualization and management for example)
• Hibernate and/or db4o for storage
• Eclipse Mylar to help the user manage lot of resources (need some adapters to adapt the Apogee resource model to the IDE's one)
• Eclipse BIRT for the reporting service
• ObjectWeb Sync4J for the synchronization service
• Apache Lucene for the seach service
• Apache Derby (for the physical storage)
• OpenRDF Sesame for the relation service / RDF database
• NLOG4J as logging service
• Apache Common HTTPClient as HTTP client module
• EHCache as Hibernate caching service

This project will be heavily based on open standard :

• W3C XMLSchema for content/data schemas
• W3C XForms for forms provided by the ECM platform (edit view, workflow actions forms, search form, etc.)
• RDF as relation format
• XMPP as communication protocol / XML bus / event channel
• SOAP