"""base application's entities class implementation: `AnyEntity`
:organization: Logilab
:copyright: 2001-2008 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
"""
__docformat__ = "restructuredtext en"
from warnings import warn
from logilab.common.deprecation import deprecated_function
from logilab.common.decorators import cached
from cubicweb import Unauthorized, typed_eid
from cubicweb.common.utils import dump_class
from cubicweb.common.entity import Entity
from cubicweb.schema import FormatConstraint
from cubicweb.interfaces import IBreadCrumbs
class AnyEntity(Entity):
"""an entity instance has e_schema automagically set on the class and
instances have access to their issuing cursor
"""
id = 'Any'
__rtags__ = {
'is' : ('generated', 'link'),
'is_instance_of' : ('generated', 'link'),
'identity' : ('generated', 'link'),
# use primary and not generated for eid since it has to be an hidden
# field in edition
('eid', '*', 'subject'): 'primary',
('creation_date', '*', 'subject'): 'generated',
('modification_date', '*', 'subject'): 'generated',
('has_text', '*', 'subject'): 'generated',
('require_permission', '*', 'subject') : ('generated', 'link'),
('owned_by', '*', 'subject') : ('generated', 'link'),
('created_by', '*', 'subject') : ('generated', 'link'),
('wf_info_for', '*', 'subject') : ('generated', 'link'),
('wf_info_for', '*', 'object') : ('generated', 'link'),
('description', '*', 'subject'): 'secondary',
# XXX should be moved in their respective cubes
('filed_under', '*', 'subject') : ('generic', 'link'),
('filed_under', '*', 'object') : ('generic', 'create'),
# generated since there is a componant to handle comments
('comments', '*', 'subject') : ('generated', 'link'),
('comments', '*', 'object') : ('generated', 'link'),
}
__implements__ = (IBreadCrumbs,)
@classmethod
def selected(cls, etype):
"""the special Any entity is used as the default factory, so
the actual class has to be constructed at selection time once we
have an actual entity'type
"""
if cls.id == etype:
return cls
usercls = dump_class(cls, etype)
usercls.id = etype
usercls.__initialize__()
return usercls
fetch_attrs = ('modification_date',)
@classmethod
def fetch_order(cls, attr, var):
"""class method used to control sort order when multiple entities of
this type are fetched
"""
return cls.fetch_unrelated_order(attr, var)
@classmethod
def fetch_unrelated_order(cls, attr, var):
"""class method used to control sort order when multiple entities of
this type are fetched to use in edition (eg propose them to create a
new relation on an edited entity).
"""
if attr == 'modification_date':
return '%s DESC' % var
return None
@classmethod
def __initialize__(cls):
super(ANYENTITY, cls).__initialize__() # XXX
eschema = cls.e_schema
eschema.format_fields = {}
# set a default_ATTR method for rich text format fields
for attr, formatattr in eschema.rich_text_fields():
if not hasattr(cls, 'default_%s' % formatattr):
setattr(cls, 'default_%s' % formatattr, cls._default_format)
eschema.format_fields[formatattr] = attr
def _default_format(self):
return self.req.property_value('ui.default-text-format')
def use_fckeditor(self, attr):
"""return True if fckeditor should be used to edit entity's attribute named
`attr`, according to user preferences
"""
req = self.req
if req.property_value('ui.fckeditor') and self.has_format(attr):
if self.has_eid() or '%s_format' % attr in self:
return self.format(attr) == 'text/html'
return req.property_value('ui.default-text-format') == 'text/html'
return False
# meta data api ###########################################################
def dc_title(self):
"""return a suitable *unicode* title for this entity"""
for rschema, attrschema in self.e_schema.attribute_definitions():
if rschema.meta:
continue
value = self.get_value(rschema.type)
if value:
# make the value printable (dates, floats, bytes, etc.)
return self.printable_value(rschema.type, value, attrschema.type,
format='text/plain')
return u'%s #%s' % (self.dc_type(), self.eid)
def dc_long_title(self):
"""return a more detailled title for this entity"""
return self.dc_title()
def dc_description(self, format='text/plain'):
"""return a suitable description for this entity"""
if hasattr(self, 'description'):
return self.printable_value('description', format=format)
return u''
def dc_authors(self):
"""return a suitable description for the author(s) of the entity"""
try:
return ', '.join(u.name() for u in self.owned_by)
except Unauthorized:
return u''
def dc_creator(self):
"""return a suitable description for the creator of the entity"""
if self.creator:
return self.creator.name()
return u''
def dc_date(self, date_format=None):# XXX default to ISO 8601 ?
"""return latest modification date of this entity"""
return self.format_date(self.modification_date, date_format=date_format)
def dc_type(self, form=''):
"""return the display name for the type of this entity (translated)"""
return self.e_schema.display_name(self.req, form)
display_name = deprecated_function(dc_type) # require agueol > 0.8.1, asteretud > 0.10.0 for removal
def dc_language(self):
"""return language used by this entity (translated)"""
# check if entities has internationalizable attributes
# XXX one is enough or check if all String attributes are internationalizable?
for rschema, attrschema in self.e_schema.attribute_definitions():
if rschema.rproperty(self.e_schema, attrschema,
'internationalizable'):
return self.req._(self.req.user.property_value('ui.language'))
return self.req._(self.vreg.property_value('ui.language'))
@property
def creator(self):
"""return the EUser entity which has created this entity, or None if
unknown or if the curent user doesn't has access to this euser
"""
try:
return self.created_by[0]
except (Unauthorized, IndexError):
return None
def breadcrumbs(self, view=None, recurs=False):
path = [self]
if hasattr(self, 'parent'):
parent = self.parent()
if parent is not None:
try:
path = parent.breadcrumbs(view, True) + [self]
except TypeError:
warn("breadcrumbs method's now takes two arguments "
"(view=None, recurs=False), please update",
DeprecationWarning)
path = parent.breadcrumbs(view) + [self]
if not recurs:
if view is None:
if 'vtitle' in self.req.form:
# embeding for instance
path.append( self.req.form['vtitle'] )
elif view.id != 'primary' and hasattr(view, 'title'):
path.append( self.req._(view.title) )
return path
# abstractions making the whole things (well, some at least) working ######
@classmethod
def get_widget(cls, rschema, x='subject'):
"""return a widget to view or edit a relation
notice that when the relation support multiple target types, the widget
is necessarily the same for all those types
"""
# let ImportError propage if web par isn't available
from cubicweb.web.widgets import widget
if isinstance(rschema, basestring):
rschema = cls.schema.rschema(rschema)
if x == 'subject':
tschema = rschema.objects(cls.e_schema)[0]
wdg = widget(cls.vreg, cls, rschema, tschema, 'subject')
else:
tschema = rschema.subjects(cls.e_schema)[0]
wdg = widget(cls.vreg, tschema, rschema, cls, 'object')
return wdg
def sortvalue(self, rtype=None):
"""return a value which can be used to sort this entity or given
entity's attribute
"""
if rtype is None:
return self.dc_title().lower()
value = self.get_value(rtype)
# do not restrict to `unicode` because Bytes will return a `str` value
if isinstance(value, basestring):
return self.printable_value(rtype, format='text/plain').lower()
return value
def after_deletion_path(self):
"""return (path, parameters) which should be used as redirect
information when this entity is being deleted
"""
return str(self.e_schema).lower(), {}
def add_related_schemas(self):
"""this is actually used ui method to generate 'addrelated' actions from
the schema.
If you're using explicit 'addrelated' actions for an entity types, you
should probably overrides this method to return an empty list else you
may get some unexpected actions.
"""
req = self.req
eschema = self.e_schema
for role, rschemas in (('subject', eschema.subject_relations()),
('object', eschema.object_relations())):
for rschema in rschemas:
if rschema.is_final():
continue
# check the relation can be added as well
if role == 'subject'and not rschema.has_perm(req, 'add', fromeid=self.eid):
continue
if role == 'object'and not rschema.has_perm(req, 'add', toeid=self.eid):
continue
# check the target types can be added as well
for teschema in rschema.targets(eschema, role):
if not self.relation_mode(rschema, teschema, role) == 'create':
continue
if teschema.has_local_role('add') or teschema.has_perm(req, 'add'):
yield rschema, teschema, role
def relation_mode(self, rtype, targettype, role='subject'):
"""return a string telling if the given relation is usually created
to a new entity ('create' mode) or to an existant entity ('link' mode)
"""
return self.rtags.get_mode(rtype, targettype, role)
# edition helper functions ################################################
def relations_by_category(self, categories=None, permission=None):
if categories is not None:
if not isinstance(categories, (list, tuple, set, frozenset)):
categories = (categories,)
if not isinstance(categories, (set, frozenset)):
categories = frozenset(categories)
eschema, rtags = self.e_schema, self.rtags
if self.has_eid():
eid = self.eid
else:
eid = None
for rschema, targetschemas, role in eschema.relation_definitions(True):
if rschema in ('identity', 'has_text'):
continue
# check category first, potentially lower cost than checking
# permission which may imply rql queries
if categories is not None:
targetschemas = [tschema for tschema in targetschemas
if rtags.get_tags(rschema.type, tschema.type, role).intersection(categories)]
if not targetschemas:
continue
tags = rtags.get_tags(rschema.type, role=role)
if permission is not None:
# tag allowing to hijack the permission machinery when
# permission is not verifiable until the entity is actually
# created...
if eid is None and ('%s_on_new' % permission) in tags:
yield (rschema, targetschemas, role)
continue
if rschema.is_final():
if not rschema.has_perm(self.req, permission, eid):
continue
elif role == 'subject':
if not ((eid is None and rschema.has_local_role(permission)) or
rschema.has_perm(self.req, permission, fromeid=eid)):
continue
# on relation with cardinality 1 or ?, we need delete perm as well
# if the relation is already set
if (permission == 'add'
and rschema.cardinality(eschema, targetschemas[0], role) in '1?'
and self.has_eid() and self.related(rschema.type, role)
and not rschema.has_perm(self.req, 'delete', fromeid=eid,
toeid=self.related(rschema.type, role)[0][0])):
continue
elif role == 'object':
if not ((eid is None and rschema.has_local_role(permission)) or
rschema.has_perm(self.req, permission, toeid=eid)):
continue
# on relation with cardinality 1 or ?, we need delete perm as well
# if the relation is already set
if (permission == 'add'
and rschema.cardinality(targetschemas[0], eschema, role) in '1?'
and self.has_eid() and self.related(rschema.type, role)
and not rschema.has_perm(self.req, 'delete', toeid=eid,
fromeid=self.related(rschema.type, role)[0][0])):
continue
yield (rschema, targetschemas, role)
def srelations_by_category(self, categories=None, permission=None):
result = []
for rschema, ttypes, target in self.relations_by_category(categories,
permission):
if rschema.is_final():
continue
result.append( (rschema.display_name(self.req, target), rschema, target) )
return sorted(result)
def attribute_values(self, attrname):
if self.has_eid() or attrname in self:
try:
values = self[attrname]
except KeyError:
values = getattr(self, attrname)
# actual relation return a list of entities
if isinstance(values, list):
return [v.eid for v in values]
return (values,)
# the entity is being created, try to find default value for
# this attribute
try:
values = self.req.form[attrname]
except KeyError:
try:
values = self[attrname] # copying
except KeyError:
values = getattr(self, 'default_%s' % attrname,
self.e_schema.default(attrname))
if callable(values):
values = values()
if values is None:
values = ()
elif not isinstance(values, (list, tuple)):
values = (values,)
return values
def linked_to(self, rtype, target, remove=True):
"""if entity should be linked to another using __linkto form param for
the given relation/target, return eids of related entities
This method is consuming matching link-to information from form params
if `remove` is True (by default).
"""
try:
return self.__linkto[(rtype, target)]
except AttributeError:
self.__linkto = {}
except KeyError:
pass
linktos = list(self.req.list_form_param('__linkto'))
linkedto = []
for linkto in linktos[:]:
ltrtype, eid, lttarget = linkto.split(':')
if rtype == ltrtype and target == lttarget:
# delete __linkto from form param to avoid it being added as
# hidden input
if remove:
linktos.remove(linkto)
self.req.form['__linkto'] = linktos
linkedto.append(typed_eid(eid))
self.__linkto[(rtype, target)] = linkedto
return linkedto
def pre_web_edit(self):
"""callback called by the web editcontroller when an entity will be
created/modified, to let a chance to do some entity specific stuff.
Do nothing by default.
"""
pass
# server side helpers #####################################################
def notification_references(self, view):
"""used to control References field of email send on notification
for this entity. `view` is the notification view.
Should return a list of eids which can be used to generate message ids
of previously sent email
"""
return ()
# XXX: store a reference to the AnyEntity class since it is hijacked in goa
# configuration and we need the actual reference to avoid infinite loops
# in mro
ANYENTITY = AnyEntity
def fetch_config(fetchattrs, mainattr=None, pclass=AnyEntity, order='ASC'):
if pclass is ANYENTITY:
pclass = AnyEntity # AnyEntity and ANYENTITY may be different classes
if pclass is not None:
fetchattrs += pclass.fetch_attrs
if mainattr is None:
mainattr = fetchattrs[0]
@classmethod
def fetch_order(cls, attr, var):
if attr == mainattr:
return '%s %s' % (var, order)
return None
return fetchattrs, fetch_order