"""Core hooks: check for data integrity according to the instance'schema

validity

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

__docformat__ = "restructuredtext en"

from cubicweb import ValidationError

from cubicweb.selectors import entity_implements

from cubicweb.common.uilib import soup2xhtml

from cubicweb.server import hook

from cubicweb.server.pool import LateOperation, PreCommitOperation

# special relations that don't have to be checked for integrity, usually

# because they are handled internally by hooks (so we trust ourselves)

DONT_CHECK_RTYPES_ON_ADD = set(('owned_by', 'created_by',

                                'is', 'is_instance_of',

                                'wf_info_for', 'from_state', 'to_state'))

DONT_CHECK_RTYPES_ON_DEL = set(('is', 'is_instance_of',

                                'wf_info_for', 'from_state', 'to_state'))

class _CheckRequiredRelationOperation(hook.LateOperation):

    """checking relation cardinality has to be done after commit in

    case the relation is being replaced

    """

    eid, rtype = None, None

    def precommit_event(self):

        # recheck pending eids

        if self.session.deleted_in_transaction(self.eid):

            return

        if self.session.unsafe_execute(*self._rql()).rowcount < 1:

            etype = self.session.describe(self.eid)[0]

            _ = self.session._

            msg = _('at least one relation %(rtype)s is required on %(etype)s (%(eid)s)')

            msg %= {'rtype': _(self.rtype), 'etype': _(etype), 'eid': self.eid}

            raise ValidationError(self.eid, {self.rtype: msg})

    def commit_event(self):

        pass

    def _rql(self):

        raise NotImplementedError()

class _CheckSRelationOp(_CheckRequiredRelationOperation):

    """check required subject relation"""

    def _rql(self):

        return 'Any O WHERE S eid %%(x)s, S %s O' % self.rtype, {'x': self.eid}, 'x'

class _CheckORelationOp(_CheckRequiredRelationOperation):

    """check required object relation"""

    def _rql(self):

        return 'Any S WHERE O eid %%(x)s, S %s O' % self.rtype, {'x': self.eid}, 'x'

class IntegrityHook(hook.Hook):

    __abstract__ = True

    category = 'integrity'

class CheckCardinalityHook(IntegrityHook):

    """check cardinalities are satisfied"""

    __id__ = 'checkcard'

    events = ('after_add_entity', 'before_delete_relation')

    def __call__(self):

        getattr(self, self.event)()

    def checkrel_if_necessary(self, opcls, rtype, eid):

        """check an equivalent operation has not already been added"""

            if isinstance(op, opcls) and op.rtype == rtype and op.eid == eid:

                break

        else:

    def after_add_entity(self):

        eid = self.entity.eid

        eschema = self.entity.e_schema

        for rschema, targetschemas, x in eschema.relation_definitions():

            # skip automatically handled relations

            if rschema.type in DONT_CHECK_RTYPES_ON_ADD:

                continue

            if x == 'subject':

                subjtype = eschema

                objtype = targetschemas[0].type

                cardindex = 0

                opcls = _CheckSRelationOp

            else:

                subjtype = targetschemas[0].type

                objtype = eschema

                cardindex = 1

                opcls = _CheckORelationOp

            card = rschema.rproperty(subjtype, objtype, 'cardinality')

            if card[cardindex] in '1+':

                self.checkrel_if_necessary(opcls, rschema.type, eid)

    def before_delete_relation(self):

        rtype = self.rtype

        if rtype in DONT_CHECK_RTYPES_ON_DEL:

            return

        eidfrom, eidto = self.eidfrom, self.eidto

        card = session.schema_rproperty(rtype, eidfrom, eidto, 'cardinality')

        pendingrdefs = session.transaction_data.get('pendingrdefs', ())

        if (session.describe(eidfrom)[0], rtype, session.describe(eidto)[0]) in pendingrdefs:

            return

        if card[0] in '1+' and not session.deleted_in_transaction(eidfrom):

            self.checkrel_if_necessary(_CheckSRelationOp, rtype, eidfrom)

        if card[1] in '1+' and not session.deleted_in_transaction(eidto):

            self.checkrel_if_necessary(_CheckORelationOp, rtype, eidto)

class _CheckConstraintsOp(hook.LateOperation):

    """check a new relation satisfy its constraints

    """

    def precommit_event(self):

        eidfrom, rtype, eidto = self.rdef

        # first check related entities have not been deleted in the same

        # transaction

        if self.session.deleted_in_transaction(eidfrom):

            return

        if self.session.deleted_in_transaction(eidto):

            return

        for constraint in self.constraints:

            try:

                constraint.repo_check(self.session, eidfrom, rtype, eidto)

            except NotImplementedError:

                self.critical('can\'t check constraint %s, not supported',

                              constraint)

    def commit_event(self):

        pass

class CheckConstraintHook(IntegrityHook):

    """check the relation satisfy its constraints

    this is delayed to a precommit time operation since other relation which

    will make constraint satisfied may be added later.

    """

    __id__ = 'checkconstraint'

    events = ('after_add_relation',)

    def __call__(self):

                                'constraints')

        if constraints:

                               rdef=(self.eidfrom, self.rtype, self.eidto))

class CheckUniqueHook(IntegrityHook):

    __id__ = 'checkunique'

    events = ('before_add_entity', 'before_update_entity')

    def __call__(self):

        entity = self.entity

        eschema = entity.e_schema

        for attr in entity.edited_attributes:

            val = entity[attr]

            if val is None:

                continue

            if eschema.subject_relation(attr).is_final() and \

                   eschema.has_unique_values(attr):

                rql = '%s X WHERE X %s %%(val)s' % (entity.e_schema, attr)

                if rset and rset[0][0] != entity.eid:

                    raise ValidationError(entity.eid, {attr: msg % val})

class _DelayedDeleteOp(hook.Operation):

    """delete the object of composite relation except if the relation

    has actually been redirected to another composite

    """

    def precommit_event(self):

        session = self.session

        # don't do anything if the entity is being created or deleted

        if not (session.deleted_in_transaction(self.eid) or

                session.added_in_transaction(self.eid)):

            etype = session.describe(self.eid)[0]

            session.unsafe_execute('DELETE %s X WHERE X eid %%(x)s, NOT %s'

                                   % (etype, self.relation),

                                   {'x': self.eid}, 'x')

class DeleteCompositeOrphanHook(IntegrityHook):

    """delete the composed of a composite relation when this relation is deleted

    """

    __id__ = 'deletecomposite'

    events = ('before_delete_relation',)

    def __call__(self):

                                                 'composite')

        if composite == 'subject':

                             relation='Y %s X' % self.rtype)

        elif composite == 'object':

                             relation='X %s Y' % self.rtype)

class DontRemoveOwnersGroupHook(IntegrityHook):

    """delete the composed of a composite relation when this relation is deleted

    """

    __id__ = 'checkownersgroup'

    __select__ = IntegrityHook.__select__ & entity_implements('CWGroup')

    events = ('before_delete_entity', 'before_update_entity')

    def __call__(self):

        if self.event == 'before_delete_entity' and self.entity.name == 'owners':

        elif self.event == 'before_update_entity' and 'name' in self.entity.edited_attribute:

            newname = self.entity.pop('name')

            oldname = self.entity.name

            if oldname == 'owners' and newname != oldname:

            self.entity['name'] = newname

class TidyHtmlFields(IntegrityHook):

    """tidy HTML in rich text strings"""

    __id__ = 'htmltidy'

    events = ('before_add_entity', 'before_update_entity')

    def __call__(self):

        entity = self.entity

        metaattrs = entity.e_schema.meta_attributes()

        for metaattr, (metadata, attr) in metaattrs.iteritems():

            if metadata == 'format' and attr in entity.edited_attributes:

                try:

                    value = entity[attr]

                except KeyError:

                    continue # no text to tidy

                if isinstance(value, unicode): # filter out None and Binary

                    if getattr(entity, str(metaattr)) == 'text/html':

class StripCWUserLoginHook(IntegrityHook):

    """ensure user logins are stripped"""

    __id__ = 'stripuserlogin'

    __select__ = IntegrityHook.__select__ & entity_implements('CWUser')

    events = ('before_add_entity', 'before_update_entity',)

    def call(self, session, entity):

        if 'login' in entity.edited_attributes and entity['login']:

            entity['login'] = entity['login'].strip()