There are enough template languages out there. You can use your

preferred template language if you want. [explain how to use a

template language]

*CubicWeb* does not define its own templating language as this was

not our goal. Based on our experience, we realized that

we could gain productivity by letting designers use design tools

and developpers develop without the use of the templating language

as an intermediary that could not be anyway efficient for both parties.

Python is the templating language that we use in *CubicWeb*, but again,

it does not prevent you from using a templating language.

The reason template languages are not used in this book is that

experience has proved us that using pure python was less cumbersome.

Python is an Object Oriented Programming language and as such it

already provides a consistent and strong architecture and syntax

a templating language would not reach.

When doing development, you need a real language and template

languages are not real languages.

Using Python instead of a template langage for describing the user interface

makes it to maintain with real functions/classes/contexts without the need of

learning a new dialect. By using Python, we use standard OOP techniques and

this is a key factor in a robust application.

LGPL means that *if* you redistribute your application, you need to

redistribute the changes you made to CubicWeb under the LGPL licence.

Publishing a web site has nothing to do with redistributing

source code. A fair amount of companies use modified LGPL code

for internal use. And someone could publish a *CubicWeb* component

under a BSD licence for others to plug into a LGPL framework without

any problem. The only thing we are trying to prevent here is someone

taking the framework and packaging it as closed source to his own

clients.

It is constantly evolving, piece by piece.  The framework has evolved since

2001 and data has been migrated from one schema to the other ever since. There

is a well-defined way to handle data and schema migration.

It may remind you of SQL but it is higher level than SQL, more like

SPARQL. Except that SPARQL did not exist when we started the project.

With version 3.4, CubicWeb has support for SPARQL.

That RQL language is what is going to make a difference with django-

like frameworks for several reasons.

1. accessing data is *much* easier with it. One can write complex

   queries with RQL that would be tedious to define and hard to maintain

   using an object/filter suite of method calls.

2. it offers an abstraction layer allowing your applications to run

   on multiple back-ends. That means not only various SQL backends

   (postgresql, sqlite, mysql), but also multiple databases at the

   same time, and also non-SQL data stores like LDAP directories and

   subversion/mercurial repositories (see the `vcsfile`

   component). Google App Engine is yet another supported target for

   RQL.

This is an example of how it works in our framework:

.. sourcecode:: python

                               ERQLExpression('X version_of PROJ, U in_group G, '

                                              'PROJ require_permission P, '

                                              'P name "add_version", P require_group G'),)}

The above means that permission to read a Version is granted to any

user that is part of one of the groups 'managers', 'users', 'guests'.

The 'add' permission is granted to users in group 'managers' or

'logilab' and to users in group G, if G is linked by a permission

entity named "add_version" to the version's project.

.. sourcecode:: python

                               RRQLExpression('O require_permission P, P name "add_version", '

                               'U in_group G, P require_group G'),) }

You can find additional information in the section :ref:`security`.

[XXX what does the second example means in addition to the first one?]

While modifying the description of an entity, you get an error message in

the instance `Error while publishing ...` for Rest text and plain text.

The server returns a traceback like as follows ::

This can be fixed by applying the patch described in :

http://code.google.com/p/googleappengine/issues/detail?id=48

Hooks are executed around (actually before or after) events.  The

most common events are data creation, update and deletion.  They

permit additional constraint checking (those not expressible at the

schema level), pre and post computations depending on data

movements.

As such, they are a vital part of the framework.

Other kinds of hooks, called Operations, are available

for execution just before commit.

An HTML template cannot contain code, hence it is only about static

content.  A component is made of code and operations that apply on a

well defined context (request, result set). It enables much more

dynamic views.

`AppRsetObject` instances are selected on a request and a result

set. `AppObject` instances are directly selected by id.

It depends on what has been modified in the schema.

* Update the permissions and properties of an entity or a relation:

  ``sync_schema_props_perms('MyEntityOrRelation')``.

* Add an attribute: ``add_attribute('MyEntityType', 'myattr')``.

* Add a relation: ``add_relation_definition('SubjRelation', 'MyRelation', 'ObjRelation')``.

This allows to bypass authentication for your site. In the

``all-in-one.conf`` file of your instance, define the anonymous user

as follows ::

  # login of the CubicWeb user account to use for anonymous user (if you want to

  # allow anonymous)

  anonymous-user=anon

  # password of the CubicWeb user account matching login

  anonymous-password=anon

You also must ensure that this `anon` user is a registered user of

the DB backend. If not, you can create through the administation

interface of your instance by adding a user with the role `guests`.

This could be the admin account (for development

purposes, of course).

There are two ways of changing the logo.

1. The easiest way to use a different logo is to replace the existing

   ``logo.png`` in ``myapp/data`` by your prefered icon and refresh.

   By default all instance will look for a ``logo.png`` to be

   rendered in the logo section.

   .. image:: ../images/lax-book.06-main-template-logo.en.png

2. In your cube directory, you can specify which file to use for the logo.

   This is configurable in ``mycube/data/external_resources``: ::

     LOGO = DATADIR/path/to/mylogo.gif

   where DATADIR is ``mycube/data``.

Your instance's sources are defined in ``/etc/cubicweb.d/myapp/sources``.

Configuring an LDAP source is about declaring that source in your

instance configuration file such as: ::

  [ldapuser]

  adapter=ldapuser

  # ldap host

  host=myhost

  # base DN to lookup for usres

  user-base-dn=ou=People,dc=mydomain,dc=fr

  # user search scope

  user-scope=ONELEVEL

  # classes of user

  user-classes=top,posixAccount

  # attribute used as login on authentication

  user-login-attr=uid

  # name of a group in which ldap users will be by default

  user-default-group=users

  # map from ldap user attributes to cubicweb attributes

  user-attrs-map=gecos:email,uid:login

Any change applied to configuration file requires to restart your

instance.

You just need to put the appropriate context manager around view/component

selection (one standard place in in vreg.py):

.. sourcecode:: python

Don't forget the 'from __future__ import with_statement' at the module

top-level.

This will yield additional WARNINGs, like this::

If your schema has an attribute of type Date or Datetime, you might

want to format it. First, you should define your preferred format using

the site configuration panel ``http://appurl/view?vid=systempropertiesform``

and then set ``ui.date`` and/or ``ui.datetime``.

Then in the view code, use:

.. sourcecode:: python

If you have PostgreSQL set up to accept kerberos authentication, you can set

the db-host, db-name and db-user parameters in the `sources` configuration

file while leaving the password blank. It should be enough for your

instance to connect to postgresql with a kerberos ticket.

The following script aims at loading data within a script assuming pyro-nsd is

running and your instance is configured with ``pyro-server=yes``, otherwise

you would not be able to use dbapi.

.. sourcecode:: python

If you take a look at your instance schema and

click on "display detailed view of metadata" you will see that there

is a Euser entity in there. That's the one that is modeling users. The

thing that corresponds to a UserProperty is a relationship between

your entity and the Euser entity. As in:

.. sourcecode:: python

[XXX check that cw handle users better by mapping Google Accounts to local Euser

entities automatically]

If you want to reset the admin password for ``myinstance``, do::

    $ cubicweb-ctl reset-admin-pwd myinstance

You need to generate a new encrypted password::

and paste it in the database::

  remove {'PR': 'Project', 'C': 'CWUser'} from solutions since your_user has no read access to cost

This is because you have to put your user in the "users" group. The user has to be in both groups.