Add custom checker for Password values
We override the default converter to pass Binary values through, but
don't do anything about the checker. This worked previously because
yams allowed StringIO instances, although its converter didn't do the
right thing for them. Fixing this in yams requires that we properly
register a checker.
# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
#
# This file is part of CubicWeb.
#
# CubicWeb is free software: you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 2.1 of the License, or (at your option)
# any later version.
#
# CubicWeb is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with CubicWeb. If not, see <http://www.gnu.org/licenses/>.
"""helper classes to handle server-side edition of entities"""
__docformat__ = "restructuredtext en"
from copy import copy
from yams import ValidationError
_MARKER = object()
class dict_protocol_catcher(object):
def __init__(self, entity):
self.__entity = entity
def __getitem__(self, attr):
return self.__entity.cw_edited[attr]
def __setitem__(self, attr, value):
self.__entity.cw_edited[attr] = value
def __getattr__(self, attr):
return getattr(self.__entity, attr)
class EditedEntity(dict):
"""encapsulate entities attributes being written by an RQL query"""
def __init__(self, entity, **kwargs):
dict.__init__(self, **kwargs)
self.entity = entity
self.skip_security = set()
self.querier_pending_relations = {}
self.saved = False
def __hash__(self):
# dict|set keyable
return hash(id(self))
def __lt__(self, other):
# we don't want comparison by value inherited from dict
return id(self) < id(other)
def __eq__(self, other):
return id(self) == id(other)
def __setitem__(self, attr, value):
assert attr != 'eid'
# don't add attribute into skip_security if already in edited
# attributes, else we may accidentaly skip a desired security check
if attr not in self:
self.skip_security.add(attr)
self.edited_attribute(attr, value)
def __delitem__(self, attr):
assert not self.saved, 'too late to modify edited attributes'
super(EditedEntity, self).__delitem__(attr)
self.entity.cw_attr_cache.pop(attr, None)
def __copy__(self):
# default copy protocol fails in EditedEntity.__setitem__ because
# copied entity has no skip_security attribute at this point
return EditedEntity(self.entity, **self)
def pop(self, attr, *args):
# don't update skip_security by design (think to storage api)
assert not self.saved, 'too late to modify edited attributes'
value = super(EditedEntity, self).pop(attr, *args)
self.entity.cw_attr_cache.pop(attr, *args)
return value
def setdefault(self, attr, default):
assert attr != 'eid'
# don't add attribute into skip_security if already in edited
# attributes, else we may accidentaly skip a desired security check
if attr not in self:
self[attr] = default
return self[attr]
def update(self, values, skipsec=True):
if skipsec:
setitem = self.__setitem__
else:
setitem = self.edited_attribute
for attr, value in values.iteritems():
setitem(attr, value)
def edited_attribute(self, attr, value):
"""attribute being edited by a rql query: should'nt be added to
skip_security
"""
assert not self.saved, 'too late to modify edited attributes'
super(EditedEntity, self).__setitem__(attr, value)
self.entity.cw_attr_cache[attr] = value
# mark attribute as needing purge by the client
self.entity._cw_dont_cache_attribute(attr)
def oldnewvalue(self, attr):
"""returns the couple (old attr value, new attr value)
NOTE: will only work in a before_update_entity hook
"""
assert not self.saved, 'too late to get the old value'
# get new value and remove from local dict to force a db query to
# fetch old value
newvalue = self.entity.cw_attr_cache.pop(attr, _MARKER)
oldvalue = getattr(self.entity, attr)
if newvalue is not _MARKER:
self.entity.cw_attr_cache[attr] = newvalue
else:
newvalue = oldvalue
return oldvalue, newvalue
def set_defaults(self):
"""set default values according to the schema"""
for attr, value in self.entity.e_schema.defaults():
if not attr in self:
self[str(attr)] = value
def check(self, creation=False):
"""check the entity edition against its schema. Only final relation
are checked here, constraint on actual relations are checked in hooks
"""
entity = self.entity
if creation:
# on creations, we want to check all relations, especially
# required attributes
relations = [rschema for rschema in entity.e_schema.subject_relations()
if rschema.final and rschema.type != 'eid']
else:
relations = [entity._cw.vreg.schema.rschema(rtype)
for rtype in self]
try:
entity.e_schema.check(dict_protocol_catcher(entity),
creation=creation, relations=relations)
except ValidationError as ex:
ex.entity = self.entity.eid
raise
def clone(self):
thecopy = EditedEntity(copy(self.entity))
thecopy.entity.cw_attr_cache = copy(self.entity.cw_attr_cache)
thecopy.entity._cw_related_cache = {}
thecopy.update(self, skipsec=False)
return thecopy