.. -*- coding: utf-8 -*-

.. _components:

Components
===========

What is a component
-------------------

A component is a model grouping one or more entity types and/or views associated
in order to provide a specific feature or even a complete application using
others components.
You can decide to write your own set of components if you wish to re-use the 
entity types you develop. By default, LAX comes with its owns set of components
that you can start using right away.


Standard library
----------------

A library of standard components is part of the `LAX` release (look at
``lax/skel/ginco-apps``). Components provide entities and views. With
``lax-0.4``, you should get a set of application entities and system
entities you can re-use.

The available application entities are:

* addressbook: PhoneNumber and PostalAddress

* ebasket: Basket (like a shopping cart)

* eblog: Blog (a *very* basic blog)

* eclassfolder: Folder (to organize things but grouping them in folders)

* eclasstags: Tag (to tag anything)


* efile: File (to allow users to upload and store binary or text files)

* elink: Link (to collect links to web resources)

* emailinglist: MailingList (to reference a mailing-list and the URLs
  for its archives and its admin interface)

* eperson: Person (easily mixed with addressbook)

* etask: Task (something to be done between start and stop date)

* ezone: Zone (to define places within larger places, for example a
  city in a state in a country)

The available system entities are:

* ecomment: Comment (to attach comment threads to entities)



Adding comments to BlogDemo
---------------------------

To import a component in your application just change the line in the
``app.conf`` file. For example::

    included-yams-components=ecomment

will make the ``Comment`` entity available in your ``BlogDemo``
application.

Change the schema to add a relationship between ``BlogEntry`` and
``Comment`` and you are done. Since the ecomment component defines the
``comments`` relationship, adding the line::

    comments = ObjectRelation('Comment', cardinality='1*', composite='object')

to the definition of a ``BlogEntry`` will be enough.

Clear the datastore and restart.

Component structure
-------------------

A complex component is structured as follows:
::

  mycomponent/
  |
  |-- schema.py
  |
  |-- entities/
  |
  |-- sobjects/
  |
  |-- views/
  |
  |-- test/
  |
  |-- i18n/
  |
  |-- data/
  |
  |-- migration/
  | |- postcreate.py
  | \- depends.map
  |
  |-- debian/
  |
  \-- __pkginfo__.py

We can also define simple Python module instead of directories (packages), for example:
::

  mycomponent/
  |
  |-- entities.py
  |-- hooks.py
  \-- views.py


where:

* ``schema`` contains the definition of the schema (server side only)
* ``entities`` contains entities definition (server side and web interface)
* ``sobjects`` contains hooks and/or notification views (server side only)
* ``views`` contains the web interface components (web interface only)
* ``test`` contains tests related to the application (not installed)
* ``i18n`` contains messages catalogs for supported languages (server side and
  web interface)
* ``data`` contains data files for static content (images, css, javascripts)
  ...(web interface only)
* ``migration`` contains initialization file for new instances (``postcreate.py``)
  and a file containing dependencies of the component depending on the version
  (``depends.map``)
* ``debian`` contains all the files managing debian packaging (you will find
  the usual files ``control``, ``rules``, ``changelog``... not installed)
* file ``__pkginfo__.py`` provides component meta-data, especially the distribution
  and the current version(server side and web interface) or sub-components used by
  the component.
 
At least you should have:

* the file ``__pkginfo__.py``
* schema definition

[WRITE ME]

* explain the component architecture

* add comments to the blog by importing the comments component