1. NGUYỄN VĂN SANG
SKYPE SANG89VH
MAIL SANG89VH@GMAIL.COM
FACEBOOK https://www.facebook.com/sang.nguyen.792197
ĐT 01656054323
WEB 123HOIDAP.VN
Hà Nội, 20/01/2015
2. Alfresco Overview
INTRODUCTION
ARCHITECTURAL OVERVIEW
THE ALFRESCO CONTENT APPLICATION SERVER
THE CONTENT REPOSITORY
MODULARITY THROUGH A SPRING FRAMEWORK
CONTENT SERVICES
APIS
EXTENDING ALFRESCO
CONTENT MODELING
WEB APPLICATION FRAMEWORK
3. Introduction
• Alfresco is ECM (Enterprise content
management)
• Alfresco built a different kind of system using
open source development and incorporating
open source components, such as Spring,
Lucene, Hibernate,jBPM, FreeMarker, and POI.
5. Introduction
• Alfresco Applications two main applications
are Alfresco Share and Alfresco Explorer.
– The Alfresco Web Tier and Surf
– Alfresco Programming Models
6. Introduction
• CONTENT APPLICATIONS
These applications are content-rich and their
business processes tend to focus on the creation,
management, delivery, access, and use of content.
Aside from the major applications of document,
image, records, digital asset, and Web content
management, there are a number of specific
applications and use cases that add value to the
enterprise and reduce both cost and waste
7. Introduction
• Knowledge Management
Web content management is about managing
Web sites, managing the content that goes into
Web sites (such as HTML and images), and
managing the processes of building, testing, and
deploying Web sites and content.
10. Introduction
• Collaborative Content Development
Many knowledge-oriented business processes
rely on content as the container of information
captured
and developed as part of the creative process.
11. Introduction
• Case Management
Case Management is the handling of
information related to a case, such as an
insurance claim, an investigation, or personnel
processing.
14. Architectural Overview
• The Alfresco Content Application Server provides
the following categories of services
• built upon the content repository:
• ➤ Content services (for example, transformation,
tagging, metadata extraction)
• ➤ Control services (for example, workflow,
records management, change sets)
• ➤ Collaboration services (for example, social
graph, activities, wiki)
18. The Content Repository
• The storage engine also exposes query
capabilities provided by a custom query
engine built on Apache Lucene that supports
the following search constructs:
• ➤ Metadata filtering
• ➤ Path matching
• ➤ Full text search
• ➤ Any combination of the above
19. The Content Repository
Query EngineThe query engine and
storage engines are hooked into the
transaction and permission support
of the infrastructure, thus offering
consistent views and permission
access. Several query languages are
exposed , including native Lucene,
XPath, Alfresco FTS (Full Text
Search), and CMIS Query Language
(with embedded Alfresco FTS).
20. Modularity through a Spring Framework
• Alfresco employed the Spring framework for
its factory, Dependency Injection, and Aspect-
Oriented Programming capabilities.
21. Content Services
• ➤ Content— Advanced content management
capabilities
• ➤ Control— Encapsulation of processes
• ➤ Collaboration— Integration of content into
social networks
22. Content Services
• Lifecycle— Management of content state over time
• ➤ Transformation— Conversion of content from one type to
another
• ➤ Metadata Extraction— Synchronization of document metadata
with node metadata
• ➤ Tagging— Arbitrary user-generated tags versus formally defined
classifications
• Control services encapsulate processes through which content
flows and comprise the following:
• ➤ Workflow— Structured process that include a sequence of
connected steps, often involving human interactions through
allocation of tasks
• ➤ Records— File plans, record types, retention and archival
policies, disposition, and reporting, all certified to the DOD 5015.2
standard
23. Content Services
• ➤ Change Set— Working area for making safe content modifications
• ➤ Preview— Viewing of content as it should be before publishing
• ➤ Deployment: Publishing of content from one environment to another
• Collaboration services integrate the production and publishing of content
into social networks:
• ➤ Social Graph— Represents people and their relationship to each other,
either directly or indirectly through groups or teams
• ➤ Activities— Continuous personalized feed of activities performed by
others in the social graph or by Alfresco
• ➤ Wiki— Easy creation and editing of interlinked Web pages
• ➤ Blog— Log of regularly maintained entries of commentary, events, and
other material, such as documents and videos
• ➤ Discussions— Threaded conversations
24. APIs
The Alfresco Content Application Server exposes
two flavors of API, each of which has been designed
for a specific type of client:
➤ Remote API— Used by clients to remotely
communicate with the Alfresco Content Application
Server — specifically, to treat it as a black box
➤ Embedded API— Used by extensions that are
registered and executed within the Alfresco
Content Application Server
25. The Remote API
• The Remote API is the API
primarily used when
building ECM solutions
against the Alfresco Content
Application Server. Actually,
two styles of Remote API
are exposed :
• ➤ Web services— SOAP-
based service-oriented
interfaces
• ➤ RESTful— HTTP-based
resource-oriented
interfaces
26. The Embedded API
• The Embedded API is the API used when
developing extensions to the Alfresco Content
Application Server. Extensions, which are
deployed into the server, are often dependent
on existing services provided by the server.
Therefore, developers of extensions use the
Embedded API to gain access to those
services.
27. The Embedded API
• The Embedded API comes in several forms, where each form is
structured for a particular need or kind of extension
• Alfresco Java Foundation API— The set of public Java interfaces
exposed by services built into the Alfresco Content Application
Server
• ➤ JCR— Standard (JSR-170) set of Java interfaces for interacting
with the content repository
• ➤ JavaScript API— An object-oriented view of the Java Foundation
API specifically tailored for use in JavaScript
• ➤ FreeMarker API— An object-oriented view of the Java
Foundation API specifically tailored for use in FreeMarker templates
• ➤ Content Definition— An API for creating and editing content
models
• ➤ Workflow Definition— An API for defining business processes
29. The Embedded API
• ➤ Alfresco Java Foundation API—
The set of public Java interfaces
exposed by services built into the
Alfresco Content Application Server
• ➤ JCR— Standard (JSR-170) set of
Java interfaces for interacting with the
content repository
• ➤ JavaScript API— An object-
oriented view of the Java Foundation
API specifically tailored for use in
JavaScript
• ➤ FreeMarker API— An object-
oriented view of the Java Foundation
API specifically tailored for use in
FreeMarker templates
• ➤ Content Definition— An API for
creating and editing content models
• ➤ Workflow Definition— An API for
defining business processes
• ➤ Web Script— Definition and
implementation of a RESTful API
• ➤ Action— Encapsulates a process
primarily used with rules
• ➤ Transformer— Converts content
from one format to another
• ➤ Policy— Event handler registered
against an event
• ➤ Service— Encapsulates a set of
related features
• ➤ Content Model— Definition of
types, aspects, and their relationships
• ➤ Workflow— A business process
31. DEPLOYING A CONTENT MODEL
• A content model is defined in its entirety as a
single XML document, which must comply with
the content metamodel XSD schema provided by
the Alfresco content repository. Each model
contains a set of related and coherent definitions,
and is deployed as a unit.
• Two approaches to deploying a content model
into the content repository:Bootstrap and
dynamic.
32. Bootstrap
• A Dictionary Bootstrap component is defined
using the following snippet of Spring
framework XML
35. WEB APPLICATION FRAMEWORK
• ➤ Site Dispatcher— Allows you to easily create pages and link them
to the overall navigation of the Web site. It also allows you to build
pages in a way that promotes reusability so that components do
not need to be built more than once.
• ➤ Templates— Allows you to define a page layout once and then
reuse it across a large set of pages. You can develop pages using
FreeMarker, JSP, HTML, or Java.
• ➤ UI Library— Reusable UI components that can be bound into
regions (or slots) within your
• page or template. They consist of back-end application logic and
front-end presentation code.
• ➤ Pages— Allows for pages to be rendered in multiple formats,
such as print format, PDF, or mobile device.
• ➤ AJAX support— Integration with YUI Library.
• ➤ Forms— Rich Forms engine for rendering and collecting data.
40. THE WEB SCRIPT FRAMEWORK
• ➤ A description document— This describes the URI and HTTP method that will initiate the
Web script. For example, the Web script is given a short name and description, along with
authentication and transactional needs. URI bindings are described as URI templates.
• ➤ An optional controller script— Written in JavaScript, this will do the actual work. For
example, the script may query the Alfresco content repository to build a set of data items,
known as amodel, to render in the response; or for URIs that intend to modify the repository
(hopefully, PUT, POST, and DELETE method bindings), the script may update the Alfresco
repository. The JavaScript has access to the URI query string, Alfresco Content Application
Services, and content repository data entry points.
• ➤ One or more FreeMarker response templates— Known asviews, these will render output
in the correct format for your specific needs (for example, HTML, Atom, XML, RSS, JSON,
CSV, or any combination of these). The HTTP response is rendered via one of the supplied
emplates, where the chosen template is based on the required response content type or status
outcome. The template has access to the URI query string, common repository data entry
points, and any data items built by the optional controller script
43. Extending Alfresco Content Model
• Configure a custom content model
• Define and add custom aspect (set of properties)
• Define and use your custom content models
• Define associated documents for your custom
content types
• Define constraints for your custom properties
• Preview content using custom presentation
templates
• Enable dynamic customization of models without
requiring a restart of the Alfresco server
46. Implementing Workflow
• Enable simple workflow on documents
• Create e-mail templates and set e-mail notifications
• Extend workflow with multiple approval steps
• Implement advanced workflow using Activiti
• Create custom Activiti workflows
• Dynamically deploy workflow via the Activiti Console
• Create and deploy the workflow task dialog.
• Create and deploy the workflow resource bundle
• Start Advance Workflow
• Assign documents and properties to the workflow
• Assign workflow task to the users
47. Integrating External Applications with Alfresco
• Alfresco Integration Protocols
• Alfresco Web Script framework which
provides RESTful web services for integration
• Various application integration examples
including Liferay Portal, Drupal CMS, iPhone,
and Facebook
• Alfresco Support for CMIS (Content
Management Interoperability Service)
49. Customizing the User Interface
• Configure space portal views
• Add custom icons to spaces
• Extend the action menu items
• Write custom dashlets
• Use webscript as dashlets
• Write custom templates to preview content
• Write custom templates
• Write custom JSPs
• Integration with external system
51. Business Process Management
➤ Introducing workflow in Alfresco
➤ Defining a workflow
➤ Creating a process definition
➤ Creating tasks based on the task model
➤ Customizing the workflow behavior
➤ Configuring the Explorer user interface
53. DEFINING A WORKFLOW IN ALFRESCO
A workflow definition comprises aprocess definition,atask
model,andsomeuser interface configuration. All three of
these components are necessary to build a workflow.
➤ Process definition:Specifies the workflow process,
defining what human tasks and automated processes to
execute, and flow control.
➤ Task model:Provides a description of each task in a
workflow by defining the various attributes associated
with that task.
➤ UI configuration: Allows for customization of the UI
component that is used for presenting workflow-related
information to the userand taking inputs from the user.
55. DEFINING A WORKFLOW IN ALFRESCO
• A Section is best thought of as a folder with
additional metadata and behaviour. Each section
is uniquely named within its parent section. Each
website has one root section which is the only
section whose parent is not another section
• An asset is any piece of content that is placed in a
section. An asset doesn't have very much
"special" metadata, but does contain summary
information about visitor feedback that has been
received for that asset such as the number of
comments received and the average rating.
56. DEFINING A WORKFLOW IN ALFRESCO
• Asset Collection: As the name suggests, an asset
collection groups together a number of assets. Each
asset collection is associated with a particular section
and is uniquely named within that section. There are
two general types of asset collection: "dynamic" and
"static". A dynamic asset collection is configured with a
search query that is run periodically. The assets found
by the query are placed in the collection. A static asset
collection has no search query defined, and contains
assets that are placed in it either manually or through
some other automated mechanism.
57. DEFINING A WORKFLOW IN ALFRESCO
• Visitor Feedback is information that has been
passed back through a rendered website into the
repository. It may be used for numerous purposes,
but in the Quick Start example it is used to record
comments about an asset and requests from the
"Contact us" page. A piece of visitor feedback has
a number of generally useful properties such as
the name and email address of the person who
submitted it, a text property for the message or
comment, and an integer property that can be
used for ratings. It is also possible to have
different categories of visitor feedback.
Hinweis der Redaktion
Alfresco built a different kind of system using open source development and incorporating open source
components, such as Spring, Lucene, Hibernate,jBPM, FreeMarker, and POI. The Alfresco system
incorporated the major applications of ECM — document, image, Web content, record, and digital
asset management — but in an easier, more deployable package.
By adopting appropriate open standards, Alfresco generally fits in any enterprise environment.
Alfresco’s Content Application Server provides a platform for developing content applications in a
number of different development styles suitable for the programming task at hand. By being scalable,
Alfresco can adapt from small departmental solutions to large-scale Internet solutions.
The Alfresco system in many ways looks similar to other ECM systems. At the core is
a repository supported by a server that persists content, metadata, associations, and full text indexes.
There is a set of programming interfaces that support multiple languages and protocols upon which
developers can create custom applications and solutions. Out of the box applications provide standard
solutions such as document management, records management, and Web content management
The Content Application Server and the Repository
At the heart of the Alfresco system is the Content Application Server, which manages and maintains
the Content Repository. The repository is comparable to a database except that it holds more than
data. The binary streams of content are stored in the repository and the associated full-text indexes are
maintained by the Lucene indexes. The actual binary streams of the content are stored in files managed
in the repository, although these files are for internal use only and do not reflect what you might see
through the shared drive interfaces. The repository also holds the associations among content items,
classifications, and the folder/file structure. The folder/file structure is maintained in the database and
is not reflected in the internal file storage structure.
Alfresco Explorer is the original application builtwith the Alfresco system to manage content. Alfresco
Explorer allows you to browse the repository, set up rules and actions, and manage content and
its metadata, associations, and classifications. Alfresco Explorer was built using JavaServer Faces
and is integrated into the Content Application Server. It is currently being phased out in favor of
Alfresco Share. However, many extensions and language packs have been built for Alfresco Explorer.
It also has extensive capabilities for managing the repository and should be considered a system
administrator tool.
--------------------------------------------------------------------------
Alfresco Share is the next-generation user interfacebuilt entirely with the Alfresco Web script technology and can be used to extend the application. Alfresco Share provides content management capabilities
with simple user interfaces, providing users with tools to search and browse the repository; content as
thumbnails and associated metadata; previews using Flash renditions of content; and a set of collaboration tools such as Wikis, Discussions, and Blogs.Alfresco Share is also the foundation for Alfresco
records management. Alfresco Share is organized as a set of sites that can be used as a meeting place
for collaboration.
-------------------------------------------------------------------
The Alfresco Web Tier and Surf
Alfresco provides ECM capabilities as data services, user interfaces, and user applications. The user
interface capabilities are provided by applications and application components using Alfresco’s Web
tier, Surf, originally developed as a faster way to develop content applications using scripting and
REST architecture. Surf uses Web scripts heavilyto build user interface components and to access
information from the Content Application Server.In 2009, Alfresco contributed Surf as a project to the
Spring community where it can be used in conjunction with other Spring Web-tier components, such
as Spring MVC, Spring Webflow, and Grails.
--------------------------------------------------------------
Alfresco Programming Models
In order to build an application using the Alfresco Content Application Server, you have the choice of
a number of programming models. The simplestmodel for non-programmers is to use out-of-the-box
components of the Alfresco Share application andto use the Rules and Actions model, a set of conditions and actions to take on content, based on those conditions. Rules and actions can be defined using
a wizard and can perform such actions as convert content, move content, or execute a simple JavaScript
snippet. The sample Knowledge Base application uses rules and actions to do basic processing of content entered into the Knowledge Base.
Alfresco can be used to build most ECM applications. These are the applications in which enterprises
use content to engage customers, partners, and employees. These applications are content-rich and
their business processes tend to focus on the creation, management, delivery, access, and use of content. Aside from the major applications of document, image, records, digital asset, and Web content
management, there are a number of specific applications and use cases that add value to the enterprise and reduce both cost and waste. The following applications are typical of ECM and are ones that
Alfresco is particularly adept at supporting.
The Alfresco applications can often be used as the foundation for these application use cases. By applying the programming models previously discussed,you can extend these applications or build your own
applications using Alfresco.
Knowledge management is the capture of knowledge (from employees in an organization or customers
who use their products) and the provision of that knowledge in a form that others can use. Content
tends to be the best and most reusable container of knowledge in sharing that knowledge with others.
This book uses a knowledge management sample application as the basis for demonstrating how to
extend Alfresco and build your own applications
Information publishing is a specialized form of Web content management. It involves the real-time
publishing of content from different sources to the Web site and the deployment of that content to the
Web farm for Internet access. This can take the form of digital assets such as articles, written internally
or syndicated from other sources, or photos. Alfresco is used by many media companies to combine
this content and publish it to their Web sites. This straight-through publishing of information requires
both strong content control and performance to aggregate and push out the content. Alfresco is well
suited to this type of Web content management.
Records management is used to control important information that needs to be retained for extended
periods of time. You would use records management over document management in regulated or
compliant environments, such as in managing governmental information or personnel records, or
where information may be audited. Alfresco has been certified to the U.S. Government 5015.2 records
standard and is useful for controlling retention and review periods, providing specialized security, and
determining whether the records are archived or destroyed after a specified period of time. However,
no two records repositories are the same and although Alfresco records management provides a good
foundation, you may want to provide additional functionality through configuration or customization.
At the very least, you will need to configure the file plan specific to the department deploying records
management
Many knowledge-oriented business processes rely on content as the container of information captured
and developed as part of the creative process. Collaborative work such as new product development,
sales proposal preparation, or strategic planningmore often than not have a document of some sort (a
Word document, a PowerPoint presentation, or an Excel spreadsheet) that represents the fruit of the
effort. Sometimes the content is the purpose of the collaboration, such as the creation of a report or
a book like the one you are reading right now. Alfresco was used to manage the development of this
book, and it is a good example of collaborative content management. Alfresco and Alfresco Share are
useful tools in collaborative content management that aids knowledge work. Alfresco Share also provides a good platform to build specialized tools and extensions that may help either with collaboration
or with handling content in the collaborative and creative processes.
Case Management is the handling of information related to a case, such as an insurance claim, an
investigation, or personnel processing. Because of Alfresco’s document management capabilities, folder
structure, classification schemes, and workflow, it is well suited to managing cases and distributing
work in handling cases. Alfresco incorporates the jBPM business process engine from JBoss and can
handle sophisticated workflows and queue management. Alfresco has built a content-oriented task
model that aggregates all the resources required to perform specific tasks within the case handling
process.
Case Management is the handling of information related to a case, such as an insurance claim, an
investigation, or personnel processing. Because of Alfresco’s document management capabilities, folder
structure, classification schemes, and workflow, it is well suited to managing cases and distributing
work in handling cases. Alfresco incorporates the jBPM business process engine from JBoss and can
handle sophisticated workflows and queue management. Alfresco has built a content-oriented task
model that aggregates all the resources required to perform specific tasks within the case handling
process.
DM document management
WCM Web content management
RM Records Management
DAM Digital Asset Management (DAM)
Alfresco is used to implement an ECM solution such as DM, WCM, RM, and DAM;
across those solutions may also be elements of Collaboration and Search
--------------------------------------------------------------------------------------------------------------------------
Alfresco offers two primary Web-based clients:Alfresco ExplorerandAlfresco Share. Alfresco Explorer
has been offered since the initial release of Alfresco. A power-user client, it exposes all features of the
Alfresco Content Application Server. Alfresco Explorer is implemented using Java Server Faces (JSF)
and is highly customizable, but it is only deployable as part of the Alfresco Content Application Server.
-------------------------------------------------------------------------------
The Alfresco Content Application Server comprisesa content repository and value-added services for
building ECM solutions. Within the last few years, the content repository has been defined by the
following standards:
➤ CMIS (Content Management Interoperability Services)
➤ JCR (Java Content Repository / JSR-170/286)
-------------------------------------------------------------------------------
The Alfresco Content Application Server provides the following categories of services
built upon the content repository:
➤ Content services (for example, transformation, tagging, metadata extraction)
➤ Control services (for example, workflow, records management, change sets)
➤ Collaboration services (for example, social graph, activities, wiki)
Clients communicate with the Alfresco Content Application Server and its services through numerous
supported protocols. Programmatic access is offered through HTTP and SOAP, while application
access is offered through CIFS, FTP, WebDAV, IMAP, and Microsoft SharePoint protocols.
The Alfresco installer provides an out-of-the-box prepackaged deployment where the Alfresco Content
Application Server (with embedded Alfresco Explorer) and Alfresco Share are deployed as distinct Web
applications inside Apache Tomcat and configured for use with MySQL.
Clients communicate with the Alfresco Content Application Server and its services through numerous supported protocols. Programmatic access is offered through HTTP and SOAP, while application access is offered through CIFS, FTP, WebDAV, IMAP, and Microsoft SharePoint protocols.
---------------
The Alfresco installer provides an out-of-the-box prepackaged deployment where the Alfresco Content
----------------
Application Server (with embedded Alfresco Explorer) and Alfresco Share are deployed as distinct Web applications inside Apache Tomcat and configured for use with MySQL.
The primary responsibility of the server is to provide a comprehensive set of services for use in building
ECM solutions. In many respects, the server is just a black box where you place and manage content.
Just like an RDBMS, the Alfresco Content Application Server exposes a set of remote public interfaces
for allowing a client to communicate with it
------------------------------
The remote public interfaces are the only part of the server visible to the client. There are two types:
Remote APIsallow programmatic interaction with services of the server andProtocol bindingsmap
those same services for use by a protocol-compliant client.
-------------------------------
Internally, the server comprises several layers. The foundation is a set of infrastructure concerns
such as configuration, authentication, permissions, and transactions that cut across all capabilities.
By default, Alfresco stores nodes in an RDBMS while content
is stored in the file system. Using a database immediately brings
in the benefits of databases that have been developed over many
years, such as transaction support, scaling, and administration
capabilities. Alfresco uses a database abstraction layer for interacting with the database, which isolates the storage engine from
variations in SQL dialect. This eases the database porting effort,
allowing the certification of Alfresco against all the prominent
RDBMS implementations. Content is stored in the file system to allow for very large content, random
access, streaming, and options for different storage devices. Updates to content are always translated
to append operations in the file system. This allows for transaction consistency between database and
file system.
-------------------------
➤ Multilingual— Support for properties that can store multiple values indexed by locale, as
well as support for document translations.
➤ Rules/Actions— Support for declaratively defining content management processes that are
triggered when adding or updating content in folders. Think email rules. This is particularly
powerful when used with clients that interact through protocols such as CIFS and FTP.
Alfresco introduced its RESTful API in version 2.1 of its product and has since been expanding its scope to
cover all services of the Alfresco Content Application Server. Developers tend to prefer the style of this
API due to its natural alignment with the way the Web works. If you have an HTTP client then you can
communicate with Alfresco, which covers almost every environment and programming language. Other
attractions include the ease of use with AJAX-oriented Web clients. Alfresco Share, a Spring Surf–based
client, remotely communicates with the Alfresco Content Application Server exclusively through its
RESTful API. Behind the scenes, Alfresco embeds Spring Web scripts (contributed by Alfresco) for
developing its RESTful API.
Spring Surf embeds Spring Web scripts, allowing Surf component developers to use the same techniques
that were used when building Alfresco Content Application Server RESTful APIs, taking advantage of
scripting languages and a simple MVC approach.
-------------
Spring Surf Web site requires access to and management of content held within the Application Content Server, such as to support user-generated content, dynamic site artifacts, personalized
presentation, and tagging. To support this, Spring Surfprovides the following integration services:
➤ Remote— Encapsulates any number of data sources with out-of-the-box support for the
Alfresco Content Application Server
➤ Credentials— Manages user authentication with out-of-the-box support for the Alfresco
Content Application Server
----------------------------------------------
Spring Surf uses a lightweight XML-driven model to represent all site artifacts,
such as pages, templates, themes, and chrome.
This means a Spring Surf site itself can be managed
with Alfresco services such as change sets, preview, and deployment. In addition, an embedded API (as
shown in Figure 2-15) is provided to support programmatic control of the same artifacts.
----------------------
The XML and file-based nature of Spring Surf sites lends itself to being managed in Alfresco WCM
(as shown in Figure 2-16), which offers features such as:
➤ Safe editing of all Spring Surf artifacts, including the ability to snapshot your site and roll it
backward in time
➤ Review and Approve workflow of Spring Surf site changes
➤ Preview of site changes
➤ Deployment of site changes to test or production servers
A Web script is simply a service bound to a URI that responds to HTTP methods such as GET, POST,
PUT, and DELETE. While using the same underlying code, there are broadly two kinds of Web scripts:
data Web scripts and presentation Web scripts
If you’re familiar with the Model View Controller (MVC) design pattern, then you’ll be familiar with
how to create a Web script. Alfresco designed its Web Script Framework according to this pattern .Within the Alfresco community, the Web Script Framework is sometimes referred to as MVC for the Web.
➤ Extending the Alfresco repository
➤ Extending Alfresco Explorer
➤ Extending Alfresco Share
The Alfresco product suite provides several out-of-the-box applications that interact with the
core Alfresco repository through well-defined interfaces and services. These applications provide interaction with content and business logic from the repository to deliver solutions for
Enterprise Content Management (ECM).
The product suite leverages open standards andwell-understood service interfaces to provide
valuable options for customization and extension. This chapter describes the extension points
and focuses on how they are commonly used to build custom integrations and solutions. You
will then use some of these hooks in the subsequent chapters to build a custom application on
top of Spring Surf and Alfresco Share.
OVERVIEW
The Alfresco repository provides a rich platformfor building content applications. It provides
scalable storage, extensible services, RESTfulinterfaces, and a rich content-modeling facility
for building your content definitions and content-driven business processes. You can master
and maintain these definitions and processes in one single location.
Web applications can use or render the content and access it through any of the many open standards interfaces. This makes it easy and cost-effective for your organization to introduce new
applications or scale out existing applications by leveraging a common content infrastructure.
The repository can be clustered or configured standalone so as to support everything from very
small to very large throughput.
Alfresco implements workflow through severalmodular, loosely coupled components
The core components of Alfresco workflows are the workflow engine and the workflow service. Theworkflow engineis the underlying workflow implementation and is responsible for
executing workflows, managing tasks, and managing process definitions. Theworkflow service
is responsible for encapsulating the workflow engine, meaning all access to Alfresco workflows
is made through the workflow service. This ensures that Alfresco workflows and services that
use Alfresco workflows remain agnostic to theunderlying implementation. Though the underlying workflow service API is written in Java, a JavaScript API is also available. For further
information on the JavaScript Workflow API
A workflow definition comprises aprocess definition,atask model,andsomeuser interface configuration. All three of these components are necessary to build a workflow.
➤ Process definition:Specifies the workflow process, defining what human tasks and automated processes to execute, and flow control.
➤ Task model:Provides a description of each task in a workflow by defining the various attributes associated with that task. A UI component can use this description to automatically generate a user interface suitable for displaying task information, as well as to initialize a newly created task instance.
➤ UI configuration: Allows for customization of the UI component that is used for presenting workflow-related information to the userand taking inputs from the user. The Alfresco Explorer Web client allows customization of theproperty sheets used to display task information. It also uses resource bundles to customize thetext that displays. In particular, resource
bundles allow the customization of the language used to display information about a workflow or task