"""abstract action classes for CubicWeb web client

: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 cubicweb.common.appobject import AppRsetObject

from cubicweb.common.registerers import action_registerer

from cubicweb.common.selectors import add_etype_selector, \

     searchstate_selector, searchstate_accept_one_selector, \

     searchstate_accept_one_but_etype_selector

_ = unicode

class Action(AppRsetObject):

    """abstract action. Handle the .search_states attribute to match

    request search state. 

    """

    __registry__ = 'actions'

    __registerer__ = action_registerer

    __selectors__ = (searchstate_selector,)

    # by default actions don't appear in link search mode

    search_states = ('normal',) 

    property_defs = {

        'visible':  dict(type='Boolean', default=True,

                         help=_('display the action or not')),

        'order':    dict(type='Int', default=99,

                         help=_('display order of the action')),

        'category': dict(type='String', default='moreactions',

                         vocabulary=('mainactions', 'moreactions', 'addrelated',

                                     'useractions', 'siteactions', 'hidden'),

                         help=_('context where this component should be displayed')),

    }

    site_wide = True # don't want user to configuration actions eproperties

    category = 'moreactions'

    @classmethod

    def accept_rset(cls, req, rset, row, col):

        user = req.user

        action = cls.schema_action

        if row is None:

            score = 0

            need_local_check = [] 

            geteschema = cls.schema.eschema

            for etype in rset.column_types(0):

                accepted = cls.accept(user, etype)

                if not accepted:

                    return 0

                if action:

                    eschema = geteschema(etype)

                    if not user.matching_groups(eschema.get_groups(action)):

                        if eschema.has_local_role(action):

                            # have to ckeck local roles

                            need_local_check.append(eschema)

                            continue

                        else:

                            # even a local role won't be enough

                            return 0

                score += accepted

            if need_local_check:

                # check local role for entities of necessary types

                for i, row in enumerate(rset):

                    if not rset.description[i][0] in need_local_check:

                        continue

                    if not cls.has_permission(rset.get_entity(i, 0), action):

                        return 0

                    score += 1

            return score

        col = col or 0

        etype = rset.description[row][col]

        score = cls.accept(user, etype)

        if score and action:

            if not cls.has_permission(rset.get_entity(row, col), action):

                return 0

        return score

    @classmethod

    def has_permission(cls, entity, action):

        """defined in a separated method to ease overriding (see ModifyAction

        for instance)

        """

        return entity.has_perm(action)

    def url(self):

        """return the url associated with this action"""

        raise NotImplementedError

    def html_class(self):

        if self.req.selected(self.url()):

            return 'selected'

        if self.category:

            return 'box' + self.category.capitalize()

class UnregisteredAction(Action):

    """non registered action used to build boxes. Unless you set them

    explicitly, .vreg and .schema attributes at least are None.

    """

    category = None

    id = None

    def __init__(self, req, rset, title, path, **kwargs):

        Action.__init__(self, req, rset)

        self.title = req._(title)

        self._path = path

        self.__dict__.update(kwargs)

    def url(self):

        return self._path

class AddEntityAction(Action):

    """link to the entity creation form. Concrete class must set .etype and

    may override .vid

    """

    __selectors__ = (add_etype_selector, searchstate_selector)

    vid = 'creation'

    etype = None

    def url(self):

        return self.build_url(vid=self.vid, etype=self.etype)

class EntityAction(Action):

    """an action for an entity. By default entity actions are only

    displayable on single entity result if accept match.

    """

    __selectors__ = (searchstate_accept_one_selector,)

    schema_action = None

    condition = None

    @classmethod

    def accept(cls, user, etype):

        score = super(EntityAction, cls).accept(user, etype)

        if not score:

            return 0

        # check if this type of entity has the necessary relation

        if hasattr(cls, 'rtype') and not cls.relation_possible(etype):

            return 0

        return score

class LinkToEntityAction(EntityAction):

    """base class for actions consisting to create a new object

    with an initial relation set to an entity.

    Additionaly to EntityAction behaviour, this class is parametrized

    using .etype, .rtype and .target attributes to check if the

    action apply and if the logged user has access to it

    """

    etype = None

    rtype = None

    target = None

    category = 'addrelated'

    @classmethod

    def accept_rset(cls, req, rset, row, col):

        entity = rset.get_entity(row or 0, col or 0)

        # check if this type of entity has the necessary relation

        if hasattr(cls, 'rtype') and not cls.relation_possible(entity.e_schema):

            return 0

        score = cls.accept(req.user, entity.e_schema)

        if not score:

            return 0

        if not cls.check_perms(req, entity):

            return 0

        return score

    @classmethod

    def check_perms(cls, req, entity):

        if not cls.check_rtype_perm(req, entity):

            return False

        # XXX document this:

        # if user can create the relation, suppose it can create the entity

        # this is because we usually can't check "add" permission before the

        # entity has actually been created, and schema security should be

        # defined considering this

        #if not cls.check_etype_perm(req, entity):

        #    return False

        return True

    @classmethod

    def check_etype_perm(cls, req, entity):

        eschema = cls.schema.eschema(cls.etype)

        if not eschema.has_perm(req, 'add'):

            #print req.user.login, 'has no add perm on etype', cls.etype

            return False

        #print 'etype perm ok', cls

        return True

    @classmethod

    def check_rtype_perm(cls, req, entity):

        rschema = cls.schema.rschema(cls.rtype)

        # cls.target is telling us if we want to add the subject or object of

        # the relation

        if cls.target == 'subject':

            if not rschema.has_perm(req, 'add', toeid=entity.eid):

                #print req.user.login, 'has no add perm on subject rel', cls.rtype, 'with', entity

                return False

        elif not rschema.has_perm(req, 'add', fromeid=entity.eid):

            #print req.user.login, 'has no add perm on object rel', cls.rtype, 'with', entity

            return False

        #print 'rtype perm ok', cls

        return True

    def url(self):

        current_entity = self.rset.get_entity(self.row or 0, self.col or 0)

        linkto = '%s:%s:%s' % (self.rtype, current_entity.eid, self.target)

        return self.build_url(vid='creation', etype=self.etype,

                              __linkto=linkto,

                              __redirectpath=current_entity.rest_path(), # should not be url quoted!

                              __redirectvid=self.req.form.get('__redirectvid', ''))

class LinkToEntityAction2(LinkToEntityAction):

    """LinkToEntity action where the action is not usable on the same

    entity's type as the one refered by the .etype attribute

    """

    __selectors__ = (searchstate_accept_one_but_etype_selector,)