3956162881

Build Type

push

github

Committed by Michael Howitz

Commit Message

Update to deprecation warning free releases.

Run Details

4401 of 7036 branches covered (62.55%)

Branch coverage included in aggregate %.

27161 of 31488 relevant lines covered (86.26%)

0.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

55.59

/src/OFS/PropertyManager.py

##############################################################################
#
# Copyright (c) 2002 Zope Foundation and Contributors.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Property management
"""

import html

from AccessControl.class_init import InitializeClass
from AccessControl.Permissions import access_contents_information
from AccessControl.Permissions import manage_properties
from AccessControl.SecurityInfo import ClassSecurityInfo
from Acquisition import aq_base
from App.special_dtml import DTMLFile
from ExtensionClass import Base
from OFS.interfaces import IPropertyManager
from OFS.PropertySheets import DefaultPropertySheets
from OFS.PropertySheets import vps
from zExceptions import BadRequest
from zope.interface import implementer
from ZPublisher.Converters import type_converters


@implementer(IPropertyManager)
class PropertyManager(Base):
    """
    The PropertyManager mixin class provides an object with
    transparent property management. An object which wants to
    have properties should inherit from PropertyManager.

    An object may specify that it has one or more predefined
    properties, by specifying an _properties structure in its
    class::

      _properties=({'id':'title', 'type': 'string', 'mode': 'w'},
                   {'id':'color', 'type': 'string', 'mode': 'w'},
                   )

    The _properties structure is a sequence of dictionaries, where
    each dictionary represents a predefined property. Note that if a
    predefined property is defined in the _properties structure, you
    must provide an attribute with that name in your class or instance
    that contains the default value of the predefined property.

    Each entry in the _properties structure must have at least an 'id'
    and a 'type' key. The 'id' key contains the name of the property,
    and the 'type' key contains a string representing the object's type.
    The 'type' string must be one of the values: 'float', 'int', 'long',
    'string', 'lines', 'text', 'date', 'tokens', 'selection', or
    'multiple section'.

    For 'selection' and 'multiple selection' properties, there is an
    addition item in the property dictionay, 'select_variable' which
    provides the name of a property or method which returns a list of
    strings from which the selection(s) can be chosen.

    Each entry in the _properties structure may *optionally* provide a
    'mode' key, which specifies the mutability of the property. The 'mode'
    string, if present, must contain 0 or more characters from the set
    'w','d'.

    A 'w' present in the mode string indicates that the value of the
    property may be changed by the user. A 'd' indicates that the user
    can delete the property. An empty mode string indicates that the
    property and its value may be shown in property listings, but that
    it is read-only and may not be deleted.

    Entries in the _properties structure which do not have a 'mode' key
    are assumed to have the mode 'wd' (writeable and deleteable).

    To fully support property management, including the system-provided
    tabs and user interfaces for working with properties, an object which
    inherits from PropertyManager should include the following entry in
    its manage_options structure::

      {'label':'Properties', 'action':'manage_propertiesForm',}

    to ensure that a 'Properties' tab is displayed in its management
    interface. Objects that inherit from PropertyManager should also
    include the following entry in its __ac_permissions__ structure::

      ('Manage properties', ('manage_addProperty',
                             'manage_editProperties',
                             'manage_delProperties',
                             'manage_changeProperties',)),
    """

    security = ClassSecurityInfo()
    security.declareObjectProtected(access_contents_information)
    security.setPermissionDefault(access_contents_information,
                                  ('Anonymous', 'Manager'))

    manage_options = (
        {
            'label': 'Properties',
            'action': 'manage_propertiesForm',
        },
    )

    security.declareProtected(manage_properties, 'manage_propertiesForm')  # NOQA: D001,E501
    manage_propertiesForm = DTMLFile(
        'dtml/properties', globals(), property_extensible_schema__=1)
    security.declareProtected(manage_properties, 'manage_propertyTypeForm')  # NOQA: D001,E501
    manage_propertyTypeForm = DTMLFile('dtml/propertyType', globals())

    title = ''
    _properties = (
        {
            'id': 'title',
            'type': 'string',
            'mode': 'wd',
        },
    )
    _reserved_names = ()

    __propsets__ = ()
    propertysheets = vps(DefaultPropertySheets)

    @security.protected(access_contents_information)
    def valid_property_id(self, id):
        if not id or \
           id[:1] == '_' or \
           id[:3] == 'aq_' or \
           ' ' in id or \
           hasattr(aq_base(self), id) or \
           html.escape(id, True) != id:
            return 0
        return 1

    @security.protected(access_contents_information)
    def hasProperty(self, id):
        """Return true if object has a property 'id'."""
        for p in self._properties:
            if id == p['id']:
                return 1
        return 0

    @security.protected(access_contents_information)
    def getProperty(self, id, d=None):
        """Get the property 'id'.

        Returns the optional second argument or None if no such property is
        found.
        """
        if self.hasProperty(id):
            return getattr(self, id)
        return d

    @security.protected(access_contents_information)
    def getPropertyType(self, id):
        """Get the type of property 'id'.

        Returns None if no such property exists.
        """
        for md in self._properties:
            if md['id'] == id:
                return md.get('type', 'string')
        return None

    def _wrapperCheck(self, object):
        # Raise an error if an object is wrapped.
        if hasattr(object, 'aq_base'):
            raise ValueError('Invalid property value: wrapped object')
        return

    def _setPropValue(self, id, value):
        self._wrapperCheck(value)
        if type(value) == list:
            value = tuple(value)
        setattr(self, id, value)

    def _delPropValue(self, id):
        delattr(self, id)

    def _setProperty(self, id, value, type='string'):
        # for selection and multiple selection properties
        # the value argument indicates the select variable
        # of the property
        self._wrapperCheck(value)
        if not self.valid_property_id(id):
            raise BadRequest('Invalid or duplicate property id')

        if type in ('selection', 'multiple selection'):
            if not hasattr(self, value):
                raise BadRequest('No select variable %s' % value)
            self._properties = self._properties + (
                {'id': id, 'type': type, 'select_variable': value},)
            if type == 'selection':
                self._setPropValue(id, '')
            else:
                self._setPropValue(id, [])
        else:
            self._properties = self._properties + ({'id': id, 'type': type},)
            self._setPropValue(id, value)

    def _updateProperty(self, id, value):
        # Update the value of an existing property. If value
        # is a string, an attempt will be made to convert
        # the value to the type of the existing property.
        self._wrapperCheck(value)
        if not self.hasProperty(id):
            raise BadRequest(
                'The property %s does not exist' % html.escape(id, True))
        if isinstance(value, (str, bytes)):
            proptype = self.getPropertyType(id) or 'string'
            if proptype in type_converters:
                value = type_converters[proptype](value)
        self._setPropValue(id, value)

    def _delProperty(self, id):
        if not self.hasProperty(id):
            raise ValueError(
                'The property %s does not exist' % html.escape(id, True))
        self._delPropValue(id)
        self._properties = tuple(i for i in self._properties if i['id'] != id)

    @security.protected(access_contents_information)
    def propertyIds(self):
        """Return a list of property ids."""
        return [i['id'] for i in self._properties]

    @security.protected(access_contents_information)
    def propertyValues(self):
        """Return a list of actual property objects."""
        return [getattr(self, i['id']) for i in self._properties]

    @security.protected(access_contents_information)
    def propertyItems(self):
        """Return a list of (id,property) tuples."""
        return [(i['id'], getattr(self, i['id'])) for i in self._properties]

    def _propertyMap(self):
        """Return a tuple of mappings, giving meta-data for properties."""
        return self._properties

    @security.protected(access_contents_information)
    def propertyMap(self):
        """Return a tuple of mappings, giving meta-data for properties.

        Return copies of the real definitions for security.
        """
        return tuple(dict.copy() for dict in self._propertyMap())

    @security.protected(access_contents_information)
    def propertyLabel(self, id):
        """Return a label for the given property id
        """
        for p in self._properties:
            if p['id'] == id:
                return p.get('label', id)
        return id

    @security.protected(access_contents_information)
    def propertyDescription(self, id):
        """Return a description for the given property id
        """
        for p in self._properties:
            if p['id'] == id:
                return p.get('description', '')
        return id

    @security.protected(access_contents_information)
    def propdict(self):
        dict = {}
        for p in self._properties:
            dict[p['id']] = p
        return dict

    @security.protected(manage_properties)
    def manage_addProperty(self, id, value, type, REQUEST=None):
        """Add a new property via the web.

        Sets a new property with the given id, type, and value.
        """
        if type in type_converters:
            value = type_converters[type](value)
        self._setProperty(id.strip(), value, type)
        if REQUEST is not None:
            return self.manage_propertiesForm(self, REQUEST)

    @security.protected(manage_properties)
    def manage_editProperties(self, REQUEST):
        """Edit object properties via the web.

        The purpose of this method is to change all property values,
        even those not listed in REQUEST; otherwise checkboxes that
        get turned off will be ignored.  Use manage_changeProperties()
        instead for most situations.
        """
        for prop in self._propertyMap():
            name = prop['id']
            if 'w' in prop.get('mode', 'wd'):
                if prop['type'] == 'multiple selection':
                    value = REQUEST.form.get(name, [])
                else:
                    value = REQUEST.form.get(name, '')
                self._updateProperty(name, value)
        if REQUEST:
            message = "Saved changes."
            return self.manage_propertiesForm(
                self,
                REQUEST,
                manage_tabs_message=message,
            )

    @security.protected(manage_properties)
    def manage_changeProperties(self, REQUEST=None, **kw):
        """Change existing object properties.

        Change object properties by passing either a REQUEST object or
        name=value parameters
        """
        if REQUEST is None:
            props = {}
        elif isinstance(REQUEST, dict):
            props = REQUEST
        else:
            props = REQUEST.form
        if kw:
            for name, value in kw.items():
                props[name] = value
        propdict = self.propdict()
        for name, value in props.items():
            if self.hasProperty(name):
                if 'w' not in propdict[name].get('mode', 'wd'):
                    raise BadRequest(
                        '%s cannot be changed' % html.escape(name, True))
                self._updateProperty(name, value)

        if REQUEST:
            message = "Saved changes."
            return self.manage_propertiesForm(
                self,
                REQUEST,
                manage_tabs_message=message
            )

    @security.protected(manage_properties)
    def manage_changePropertyTypes(self, old_ids, props, REQUEST=None):
        """Replace one set of properties with another.

        Delete all properties that have ids in old_ids, then add a
        property for each item in props.  Each item has a new_id,
        new_value, and new_type.  The type of new_value should match
        new_type.
        """
        err = self.manage_delProperties(old_ids)
        if err:
            if REQUEST is not None:
                return err
            return
        for prop in props:
            self._setProperty(prop.new_id, prop.new_value, prop.new_type)
        if REQUEST is not None:
            return self.manage_propertiesForm(self, REQUEST)

    @security.protected(manage_properties)
    def manage_delProperties(self, ids=None, REQUEST=None):
        """Delete one or more properties specified by 'ids'."""
        if REQUEST:
            # Bugfix for property named "ids" (Casey)
            if ids == self.getProperty('ids', None):
                ids = None
            ids = REQUEST.get('_ids', ids)
        if ids is None:
            raise BadRequest('No property specified.')
        propdict = self.propdict()
        nd = self._reserved_names
        for id in ids:
            if not hasattr(aq_base(self), id):
                raise BadRequest(
                    'The property <em>%s</em> '
                    'does not exist' % html.escape(id, True))
            if ('d' not in propdict[id].get('mode', 'wd')) or (id in nd):
                raise BadRequest('Cannot delete %s' % id)
            self._delProperty(id)

        if REQUEST is not None:
            return self.manage_propertiesForm(self, REQUEST)


InitializeClass(PropertyManager)

1	##############################################################################
2	#
3	# Copyright (c) 2002 Zope Foundation and Contributors.
4	#
5	# This software is subject to the provisions of the Zope Public License,
6	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
7	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
8	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
9	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
10	# FOR A PARTICULAR PURPOSE.
11	#
12	##############################################################################
13	"""Property management	1✔
14	"""
15
16	import html	1✔
17
18	from AccessControl.class_init import InitializeClass	1✔
19	from AccessControl.Permissions import access_contents_information	1✔
20	from AccessControl.Permissions import manage_properties	1✔
21	from AccessControl.SecurityInfo import ClassSecurityInfo	1✔
22	from Acquisition import aq_base	1✔
23	from App.special_dtml import DTMLFile	1✔
24	from ExtensionClass import Base	1✔
25	from OFS.interfaces import IPropertyManager	1✔
26	from OFS.PropertySheets import DefaultPropertySheets	1✔
27	from OFS.PropertySheets import vps	1✔
28	from zExceptions import BadRequest	1✔
29	from zope.interface import implementer	1✔
30	from ZPublisher.Converters import type_converters	1✔
31
32
33	@implementer(IPropertyManager)	1✔
34	class PropertyManager(Base):	1✔
35	"""
36	The PropertyManager mixin class provides an object with
37	transparent property management. An object which wants to
38	have properties should inherit from PropertyManager.
39
40	An object may specify that it has one or more predefined
41	properties, by specifying an _properties structure in its
42	class::
43
44	_properties=({'id':'title', 'type': 'string', 'mode': 'w'},
45	{'id':'color', 'type': 'string', 'mode': 'w'},
46	)
47
48	The _properties structure is a sequence of dictionaries, where
49	each dictionary represents a predefined property. Note that if a
50	predefined property is defined in the _properties structure, you
51	must provide an attribute with that name in your class or instance
52	that contains the default value of the predefined property.
53
54	Each entry in the _properties structure must have at least an 'id'
55	and a 'type' key. The 'id' key contains the name of the property,
56	and the 'type' key contains a string representing the object's type.
57	The 'type' string must be one of the values: 'float', 'int', 'long',
58	'string', 'lines', 'text', 'date', 'tokens', 'selection', or
59	'multiple section'.
60
61	For 'selection' and 'multiple selection' properties, there is an
62	addition item in the property dictionay, 'select_variable' which
63	provides the name of a property or method which returns a list of
64	strings from which the selection(s) can be chosen.
65
66	Each entry in the _properties structure may optionally provide a
67	'mode' key, which specifies the mutability of the property. The 'mode'
68	string, if present, must contain 0 or more characters from the set
69	'w','d'.
70
71	A 'w' present in the mode string indicates that the value of the
72	property may be changed by the user. A 'd' indicates that the user
73	can delete the property. An empty mode string indicates that the
74	property and its value may be shown in property listings, but that
75	it is read-only and may not be deleted.
76
77	Entries in the _properties structure which do not have a 'mode' key
78	are assumed to have the mode 'wd' (writeable and deleteable).
79
80	To fully support property management, including the system-provided
81	tabs and user interfaces for working with properties, an object which
82	inherits from PropertyManager should include the following entry in
83	its manage_options structure::
84
85	{'label':'Properties', 'action':'manage_propertiesForm',}
86
87	to ensure that a 'Properties' tab is displayed in its management
88	interface. Objects that inherit from PropertyManager should also
89	include the following entry in its __ac_permissions__ structure::
90
91	('Manage properties', ('manage_addProperty',
92	'manage_editProperties',
93	'manage_delProperties',
94	'manage_changeProperties',)),
95	"""
96
97	security = ClassSecurityInfo()	1✔
98	security.declareObjectProtected(access_contents_information)	1✔
99	security.setPermissionDefault(access_contents_information,	1✔
100	('Anonymous', 'Manager'))
101
102	manage_options = (	1✔
103	{
104	'label': 'Properties',
105	'action': 'manage_propertiesForm',
106	},
107	)
108
109	security.declareProtected(manage_properties, 'manage_propertiesForm') # NOQA: D001,E501	1✔
110	manage_propertiesForm = DTMLFile(	1✔
111	'dtml/properties', globals(), property_extensible_schema__=1)
112	security.declareProtected(manage_properties, 'manage_propertyTypeForm') # NOQA: D001,E501	1✔
113	manage_propertyTypeForm = DTMLFile('dtml/propertyType', globals())	1✔
114
115	title = ''	1✔
116	_properties = (	1✔
117	{
118	'id': 'title',
119	'type': 'string',
120	'mode': 'wd',
121	},
122	)
123	_reserved_names = ()	1✔
124
125	__propsets__ = ()	1✔
126	propertysheets = vps(DefaultPropertySheets)	1✔
127
128	@security.protected(access_contents_information)	1✔
129	def valid_property_id(self, id):	1✔
130	if not id or \	1!
131	id[:1] == '_' or \
132	id[:3] == 'aq_' or \
133	' ' in id or \
134	hasattr(aq_base(self), id) or \
135	html.escape(id, True) != id:
136	return 0	×
137	return 1	1✔
138
139	@security.protected(access_contents_information)	1✔
140	def hasProperty(self, id):	1✔
141	"""Return true if object has a property 'id'."""
142	for p in self._properties:	1!
143	if id == p['id']:	1✔
144	return 1	1✔
145	return 0	×
146
147	@security.protected(access_contents_information)	1✔
148	def getProperty(self, id, d=None):	1✔
149	"""Get the property 'id'.
150
151	Returns the optional second argument or None if no such property is
152	found.
153	"""
154	if self.hasProperty(id):	1!
155	return getattr(self, id)	1✔
156	return d	×
157
158	@security.protected(access_contents_information)	1✔
159	def getPropertyType(self, id):	1✔
160	"""Get the type of property 'id'.
161
162	Returns None if no such property exists.
163	"""
164	for md in self._properties:	1!
165	if md['id'] == id:	1✔
166	return md.get('type', 'string')	1✔
167	return None	×
168
169	def _wrapperCheck(self, object):	1✔
170	# Raise an error if an object is wrapped.
171	if hasattr(object, 'aq_base'):	1!
172	raise ValueError('Invalid property value: wrapped object')	×
173	return	1✔
174
175	def _setPropValue(self, id, value):	1✔
176	self._wrapperCheck(value)	1✔
177	if type(value) == list:	1✔
178	value = tuple(value)	1✔
179	setattr(self, id, value)	1✔
180
181	def _delPropValue(self, id):	1✔
182	delattr(self, id)	×
183
184	def _setProperty(self, id, value, type='string'):	1✔
185	# for selection and multiple selection properties
186	# the value argument indicates the select variable
187	# of the property
188	self._wrapperCheck(value)	1✔
189	if not self.valid_property_id(id):	1!
190	raise BadRequest('Invalid or duplicate property id')	×
191
192	if type in ('selection', 'multiple selection'):	1!
193	if not hasattr(self, value):	×
194	raise BadRequest('No select variable %s' % value)	×
195	self._properties = self._properties + (	×
196	{'id': id, 'type': type, 'select_variable': value},)
197	if type == 'selection':	×
198	self._setPropValue(id, '')	×
199	else:
200	self._setPropValue(id, [])	×
201	else:
202	self._properties = self._properties + ({'id': id, 'type': type},)	1✔
203	self._setPropValue(id, value)	1✔
204
205	def _updateProperty(self, id, value):	1✔
206	# Update the value of an existing property. If value
207	# is a string, an attempt will be made to convert
208	# the value to the type of the existing property.
209	self._wrapperCheck(value)	1✔
210	if not self.hasProperty(id):	1!
211	raise BadRequest(	×
212	'The property %s does not exist' % html.escape(id, True))
213	if isinstance(value, (str, bytes)):	1✔
214	proptype = self.getPropertyType(id) or 'string'	1✔
215	if proptype in type_converters:	1!
216	value = type_converters[proptype](value)	1✔
217	self._setPropValue(id, value)	1✔
218
219	def _delProperty(self, id):	1✔
220	if not self.hasProperty(id):	×
221	raise ValueError(	×
222	'The property %s does not exist' % html.escape(id, True))
223	self._delPropValue(id)	×
224	self._properties = tuple(i for i in self._properties if i['id'] != id)	×
225
226	@security.protected(access_contents_information)	1✔
227	def propertyIds(self):	1✔
228	"""Return a list of property ids."""
229	return [i['id'] for i in self._properties]	×
230
231	@security.protected(access_contents_information)	1✔
232	def propertyValues(self):	1✔
233	"""Return a list of actual property objects."""
234	return [getattr(self, i['id']) for i in self._properties]	×
235
236	@security.protected(access_contents_information)	1✔
237	def propertyItems(self):	1✔
238	"""Return a list of (id,property) tuples."""
239	return [(i['id'], getattr(self, i['id'])) for i in self._properties]	×
240
241	def _propertyMap(self):	1✔
242	"""Return a tuple of mappings, giving meta-data for properties."""
243	return self._properties	1✔
244
245	@security.protected(access_contents_information)	1✔
246	def propertyMap(self):	1✔
247	"""Return a tuple of mappings, giving meta-data for properties.
248
249	Return copies of the real definitions for security.
250	"""
251	return tuple(dict.copy() for dict in self._propertyMap())	1✔
252
253	@security.protected(access_contents_information)	1✔
254	def propertyLabel(self, id):	1✔
255	"""Return a label for the given property id
256	"""
257	for p in self._properties:	1!
258	if p['id'] == id:	1!
259	return p.get('label', id)	1✔
260	return id	×
261
262	@security.protected(access_contents_information)	1✔
263	def propertyDescription(self, id):	1✔
264	"""Return a description for the given property id
265	"""
266	for p in self._properties:	1!
267	if p['id'] == id:	1!
268	return p.get('description', '')	1✔
269	return id	×
270
271	@security.protected(access_contents_information)	1✔
272	def propdict(self):	1✔
273	dict = {}	1✔
274	for p in self._properties:	1✔
275	dict[p['id']] = p	1✔
276	return dict	1✔
277
278	@security.protected(manage_properties)	1✔
279	def manage_addProperty(self, id, value, type, REQUEST=None):	1✔
280	"""Add a new property via the web.
281
282	Sets a new property with the given id, type, and value.
283	"""
284	if type in type_converters:	1!
285	value = type_converters[type](value)	1✔
286	self._setProperty(id.strip(), value, type)	1✔
287	if REQUEST is not None:	1!
288	return self.manage_propertiesForm(self, REQUEST)	×
289
290	@security.protected(manage_properties)	1✔
291	def manage_editProperties(self, REQUEST):	1✔
292	"""Edit object properties via the web.
293
294	The purpose of this method is to change all property values,
295	even those not listed in REQUEST; otherwise checkboxes that
296	get turned off will be ignored. Use manage_changeProperties()
297	instead for most situations.
298	"""
299	for prop in self._propertyMap():	×
300	name = prop['id']	×
301	if 'w' in prop.get('mode', 'wd'):	×
302	if prop['type'] == 'multiple selection':	×
303	value = REQUEST.form.get(name, [])	×
304	else:
305	value = REQUEST.form.get(name, '')	×
306	self._updateProperty(name, value)	×
307	if REQUEST:	×
308	message = "Saved changes."	×
309	return self.manage_propertiesForm(	×
310	self,
311	REQUEST,
312	manage_tabs_message=message,
313	)
314
315	@security.protected(manage_properties)	1✔
316	def manage_changeProperties(self, REQUEST=None, **kw):	1✔
317	"""Change existing object properties.
318
319	Change object properties by passing either a REQUEST object or
320	name=value parameters
321	"""
322	if REQUEST is None:	1!
323	props = {}	1✔
324	elif isinstance(REQUEST, dict):	×
325	props = REQUEST	×
326	else:
327	props = REQUEST.form	×
328	if kw:	1!
329	for name, value in kw.items():	1✔
330	props[name] = value	1✔
331	propdict = self.propdict()	1✔
332	for name, value in props.items():	1✔
333	if self.hasProperty(name):	1!
334	if 'w' not in propdict[name].get('mode', 'wd'):	1!
335	raise BadRequest(	×
336	'%s cannot be changed' % html.escape(name, True))
337	self._updateProperty(name, value)	1✔
338
339	if REQUEST:	1!
340	message = "Saved changes."	×
341	return self.manage_propertiesForm(	×
342	self,
343	REQUEST,
344	manage_tabs_message=message
345	)
346
347	@security.protected(manage_properties)	1✔
348	def manage_changePropertyTypes(self, old_ids, props, REQUEST=None):	1✔
349	"""Replace one set of properties with another.
350
351	Delete all properties that have ids in old_ids, then add a
352	property for each item in props. Each item has a new_id,
353	new_value, and new_type. The type of new_value should match
354	new_type.
355	"""
356	err = self.manage_delProperties(old_ids)	×
357	if err:	×
358	if REQUEST is not None:	×
359	return err	×
360	return	×
361	for prop in props:	×
362	self._setProperty(prop.new_id, prop.new_value, prop.new_type)	×
363	if REQUEST is not None:	×
364	return self.manage_propertiesForm(self, REQUEST)	×
365
366	@security.protected(manage_properties)	1✔
367	def manage_delProperties(self, ids=None, REQUEST=None):	1✔
368	"""Delete one or more properties specified by 'ids'."""
369	if REQUEST:	×
370	# Bugfix for property named "ids" (Casey)
371	if ids == self.getProperty('ids', None):	×
372	ids = None	×
373	ids = REQUEST.get('_ids', ids)	×
374	if ids is None:	×
375	raise BadRequest('No property specified.')	×
376	propdict = self.propdict()	×
377	nd = self._reserved_names	×
378	for id in ids:	×
379	if not hasattr(aq_base(self), id):	×
380	raise BadRequest(	×
381	'The property <em>%s</em> '
382	'does not exist' % html.escape(id, True))
383	if ('d' not in propdict[id].get('mode', 'wd')) or (id in nd):	×
384	raise BadRequest('Cannot delete %s' % id)	×
385	self._delProperty(id)	×
386
387	if REQUEST is not None:	×
388	return self.manage_propertiesForm(self, REQUEST)	×
389
390
391	InitializeClass(PropertyManager)	1✔

zopefoundation / Zope / 3956162881

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous