def add(self, content):
"""See zope.browser.interfaces.IAdding
"""
container = self.context
name = self.contentName
chooser = INameChooser(container)
# check precondition
checkObject(container, name, content)
if IContainerNamesContainer.providedBy(container):
# The container picks its own names.
# We need to ask it to pick one.
name = chooser.chooseName(self.contentName or '', content)
else:
request = self.request
name = request.get('add_input_name', name)
if name is None:
name = chooser.chooseName(self.contentName or '', content)
elif name == '':
name = chooser.chooseName('', content)
else:
# Invoke the name chooser even when we have a
# name. It'll do useful things with it like converting
# the incoming unicode to an ASCII string.
name = chooser.chooseName(name, content)
content.id = name
container._setObject(name, content)
self.contentName = name # Set the added object Name
return container._getOb(name)
def setup_department_portlets(obj, event):
# equaldepartments-portlet
manager = getUtility(IPortletManager, name=u"plone.leftcolumn")
mapping = getMultiAdapter((obj, manager), IPortletAssignmentMapping)
has_equaldepartments = False
for value in mapping.values():
if value.__name__ == "label_equaldepartmentsportlet":
has_equaldepartments = True
if not has_equaldepartments:
assignment_equaldepartments = equaldepartmentsportlet.EqualDepartmentsPortletAssignment(
department_uid=obj.UID()
)
chooser = INameChooser(mapping)
equaldepartments_name = chooser.chooseName(None, assignment_equaldepartments)
mapping[equaldepartments_name] = assignment_equaldepartments
# departmentportlet
manager = getUtility(IPortletManager, name=u"plone.rightcolumn")
mapping = getMultiAdapter((obj, manager), IPortletAssignmentMapping)
has_department = False
for value in mapping.values():
if value.__name__ == "label_departmentportlet":
has_department = True
if not has_department:
assignment_department = departmentportlet.DepartmentPortletAssignment(department_uid=obj.UID())
chooser = INameChooser(mapping)
department_name = chooser.chooseName(None, assignment_department)
mapping[department_name] = assignment_department
def convert_legacy_portlets(context):
"""Convert legacy portlets (left_slots, right_slots) in the given
context to new-style portlets.
"""
portletsMapping = {'portlet_login': login.Assignment(),
'portlet_news': news.Assignment(count=5),
'portlet_navigation': navigation.Assignment(),
'portlet_review': review.Assignment(),
'portlet_recent': recent.Assignment(count=5),
'portlet_related': DONT_MIGRATE,
'portlet_languages': DONT_MIGRATE,
'portlet_calendar': DONT_MIGRATE,
'portlet_events': DONT_MIGRATE,
}
if HAS_PLONE_APP_EVENT:
portletsMapping.update({
'portlet_calendar': calendar.Assignment(),
'portlet_events': events.Assignment(count=5),
})
# Convert left_slots and right_slots to portlets
left = getUtility(IPortletManager, name='plone.leftcolumn')
right = getUtility(IPortletManager, name='plone.rightcolumn')
leftAssignable = getMultiAdapter((context, left), IPortletAssignmentMapping).__of__(context)
rightAssignable = getMultiAdapter((context, right), IPortletAssignmentMapping).__of__(context)
IPortletPermissionChecker(leftAssignable)()
IPortletPermissionChecker(rightAssignable)()
leftChooser = INameChooser(leftAssignable)
rightChooser = INameChooser(rightAssignable)
left_slots = getattr(aq_base(context), 'left_slots', [])
right_slots = getattr(aq_base(context), 'right_slots', [])
for item in left_slots:
path = item.split('/')
if len(path) == 4:
newPortlet = portletsMapping.get(path[1], None)
if newPortlet is None and path[0] in ('context', 'here') and path[2] == 'macros':
newPortlet = classic.Assignment(path[1], path[3])
if newPortlet is not None and newPortlet is not DONT_MIGRATE:
leftAssignable[leftChooser.chooseName(None, newPortlet)] = newPortlet
for item in right_slots:
path = item.split('/')
if len(path) == 4:
newPortlet = portletsMapping.get(path[1], None)
if newPortlet is None and path[0] in ('context', 'here') and path[2] == 'macros':
newPortlet = classic.Assignment(path[1], path[3])
if newPortlet is not None and newPortlet is not DONT_MIGRATE:
rightAssignable[rightChooser.chooseName(None, newPortlet)] = newPortlet
context.left_slots = []
context.right_slots = []
def testNameChooser(self):
mapping = PortletAssignmentMapping()
chooser = INameChooser(mapping)
c = classic.Assignment()
mapping[chooser.chooseName(None, c)] = c
self.failUnless(c.__name__)
d = classic.Assignment()
self.failIfEqual(chooser.chooseName(None, d), c.__name__)
def testNameChooser(self):
mapping = PortletAssignmentMapping()
chooser = INameChooser(mapping)
c = classic.Assignment()
mapping[chooser.chooseName(None, c)] = c
self.assertTrue(c.__name__)
d = classic.Assignment()
self.assertFalse(chooser.chooseName(None, d) == c.__name__)
def setup_institution_portlets(obj, event):
ptool = getToolByName(obj, "portal_url")
c_uid = obj.UID()
c_root = "/" + "/".join(ptool.getRelativeContentPath(obj))
# left portlets
manager = getUtility(IPortletManager, name=u"plone.leftcolumn")
mapping = getMultiAdapter((obj, manager), IPortletAssignmentMapping)
has_navigation = False
has_equal_institutions = False
for value in mapping.values():
if value.__name__ == "navigation":
has_navigation = True
elif value.__name__ == "label_equalinstitutionsportlet":
has_equal_institutions = True
if not has_navigation:
assignment_navigation = navigation.Assignment(
name=obj.Title(), root=c_root, currentFolderOnly=False, includeTop=False, topLevel=0, bottomLevel=2
)
if not has_equal_institutions:
assignment_equalinstitutions = equalinstitutionsportlet.EqualInstitutionsPortletAssignment(
institution_uid=c_uid
)
chooser = INameChooser(mapping)
if not has_navigation:
mapping[chooser.chooseName(None, assignment_navigation)] = assignment_navigation
if not has_equal_institutions:
mapping[chooser.chooseName(None, assignment_equalinstitutions)] = assignment_equalinstitutions
# dont aquire portlets at left column
assignable = queryMultiAdapter((obj, manager), ILocalPortletAssignmentManager)
assignable.setBlacklistStatus("context", True)
# right portlets
manager = getUtility(IPortletManager, name=u"plone.rightcolumn")
mapping = getMultiAdapter((obj, manager), IPortletAssignmentMapping)
has_institution = False
for value in mapping.values():
if value.__name__ == "label_institutionportlet":
has_institution = True
if not has_institution:
assignment_institutionportlet = institutionportlet.InstitutionPortletAssignment(institution_uid=c_uid)
chooser = INameChooser(mapping)
mapping[chooser.chooseName(None, assignment_institutionportlet)] = assignment_institutionportlet
# dont aquire portlets at right column
assignable = queryMultiAdapter((obj, manager), ILocalPortletAssignmentManager)
assignable.setBlacklistStatus("context", True)
def test_chooseName(self):
namechooser = INameChooser(self.activities)
obj = createContentInContainer(self.activities,
'upfront.assessmentitem.content.assessmentitem')
self.assertEqual(namechooser.chooseName(None, obj), 'q001')
obj = createContent(
'upfront.assessmentitem.content.assessmentitem')
self.assertEqual(namechooser.chooseName(None, obj), 'q002')
self.assertEqual(namechooser.chooseName('custom', obj), 'custom')
def setup_department_portlets(obj, event):
column = getUtility(IPortletManager, name=DEPARTMENTS_PORTLET_COLUMN)
manager = getMultiAdapter((obj, column,), IPortletAssignmentMapping)
has_department = False
for value in manager.values():
if value.__name__ == 'label_departmentportlet':
has_department = True
if not has_department:
assignment_department = departmentportlet.DepartmentPortletAssignment(department_uid=obj.UID())
chooser = INameChooser(manager)
department_name = chooser.chooseName(None, assignment_department)
manager[chooser.chooseName(None, assignment_department)] = assignment_department
def moveTo(self, target, new_name=None):
"""Move this object to the `target` given.
Returns the new name within the `target`
"""
obj = self.context
container = obj.__parent__
orig_name = obj.__name__
if new_name is None:
new_name = orig_name
checkObject(target, new_name, obj)
if target is container and new_name == orig_name:
# Nothing to do
return
chooser = INameChooser(target)
new_name = chooser.chooseName(new_name, obj)
if target is container and new_name == orig_name:
# obstinate namechooser
return
target[new_name] = obj
del container[orig_name]
return new_name
def __call__(self, filename, title, description, content_type, data,
portal_type):
context = aq_inner(self.context)
error = ''
result = {}
result['success'] = None
newid = get_id_from_filename(filename, context)
chooser = INameChooser(context)
newid = chooser.chooseName(newid, context)
# consolidation because it's different upon Plone versions
if not title:
# try to split filenames because we don't want
# big titles without spaces
title = filename.rsplit('.', 1)[0]\
.replace('_', ' ')\
.replace('-', ' ')
if newid in context:
# only here for flashupload method since a check_id is done
# in standard uploader - see also XXX in quick_upload.py
raise NameError, 'Object id %s already exists' % newid
else:
upload_lock.acquire()
try:
transaction.begin()
try:
from zope.publisher.browser import TestRequest
request = TestRequest()
dataobj = FileObj(data)
dataobj.filename = filename
request.form['doc'] = dataobj
request.form['ajax'] = '1'
from fhnw.office2plone.browser.docx_importer import DocxImporter
docximport = DocxImporter(self.context, request)
docximport.docx_import()
except ImportError:
error = ''
except Unauthorized:
error = u'serverErrorNoPermission'
except ConflictError:
# rare with xhr upload / happens sometimes with flashupload
error = u'serverErrorZODBConflict'
except ValueError:
error = u'serverErrorDisallowedType'
except Exception, e:
error = u'serverError'
logger.exception(e)
if error:
if error == u'serverError':
logger.info(
"An error happens with setId from filename, "
"the file has been created with a bad id, "
"can't find %s", newid)
else:
pass
#@TODO : rollback if there has been an error
transaction.commit()
finally:
def new_user(principal, event):
"""Initialise the dashboard for a new user
"""
#import pdb; pdb.set_trace()
defaults = IDefaultPersonalPortlet(principal, None)
if defaults is None:
return
userid = principal.getId()
portlets = defaults()
for name in ('plone.rightcolumn', ):
assignments = portlets.get(name)
if assignments:
column = queryUtility(IPortletManager, name=name)
if column is not None:
# Add the default portlets only, if this is our manager.
# We must check this to avoid adding the default portlets
# when the product is not installed into the portal
# (but the event triggers even in this case)
if IPersonalPortletManager in providedBy(column):
category = column.get(USER_CATEGORY, None)
if category is not None:
manager = category.get(userid, None)
if manager is None:
manager = category[userid] = UserPortletAssignmentMapping(manager=name,
category=USER_CATEGORY,
name=userid)
chooser = INameChooser(manager)
for assignment in assignments:
manager[chooser.chooseName(None, assignment)] = assignment
def rename(obj=None, new_id=None, safe_id=False):
"""Rename the object.
:param obj: [required] Object that we want to rename.
:type obj: Content object
:param new_id: New id of the object.
:type new_id: string
:param safe_id: When False, the given id will be enforced. If the id is
conflicting with another object in the container, raise a
InvalidParameterError. When True, choose a new, non-conflicting id.
:type safe_id: boolean
:returns: Content object that was renamed
:Example: :ref:`content_rename_example`
"""
obj_id = obj.getId()
if safe_id:
try:
chooser = INameChooser(obj)
except TypeError:
chooser = INameChooser(obj.aq_parent)
new_id = chooser.chooseName(new_id, obj)
obj.aq_parent.manage_renameObject(obj_id, new_id)
return obj.aq_parent[new_id]
def _create_project(cell, context):
STATUS = {'17': 'active', '18': 'inactive', '19': 'archive'}
chooser = INameChooser(context)
project_id = chooser.chooseName(cell[2].decode('latin-1'), context)
# Create project
context.invokeFactory("Project", project_id)
project = context[project_id]
project.setExcludeFromNav(True)
# Set project attributes
project.setCode(cell[2].decode('latin-1'))
project.setName_fr(cell[16].decode('latin-1'))
project.setName_en(cell[4].decode('latin-1'))
project.setName_nl(cell[3].decode('latin-1'))
project.setContent_fr(cell[13].decode('latin-1'))
project.setContent_en(cell[20].decode('latin-1'))
project.setContent_nl(cell[7].decode('latin-1'))
project.setComments(cell[11].decode('latin-1'))
project.setUrl(cell[6].decode('latin-1'))
project.setOrganisationtype(cell[5].decode('latin-1'))
project.setStatus(STATUS.get(cell[18].decode('latin-1'), ''))
project.setRelationtype(cell[19].decode('latin-1'))
project.setStart(_get_datetime(cell[10].decode('latin-1')))
project.setEnd(_get_datetime(cell[15].decode('latin-1')))
return project
def __call__(self, name, content_type, data):
ctr = getToolByName(self.context, 'content_type_registry')
type_ = ctr.findTypeName(name.lower(), '', '') or 'File'
# XXX: quick fix for german umlauts
name = name.decode("utf8")
normalizer = getUtility(IFileNameNormalizer)
chooser = INameChooser(self.context)
# otherwise I get ZPublisher.Conflict ConflictErrors
# when uploading multiple files
upload_lock.acquire()
# this should fix #8
newid = chooser.chooseName(normalizer.normalize(name),
self.context.aq_parent)
try:
transaction.begin()
obj = ploneutils._createObjectByType(type_,
self.context, newid)
mutator = obj.getPrimaryField().getMutator(obj)
mutator(data, content_type=content_type)
obj.setTitle(name)
obj.reindexObject()
notify(ObjectInitializedEvent(obj))
notify(ObjectModifiedEvent(obj))
transaction.commit()
finally:
upload_lock.release()
return obj
def _createObj(context, event):
parent = context.aq_parent
column = getUtility(IPortletManager, name=u'plone.leftcolumn', context=context)
manager = getMultiAdapter((context, column,), IPortletAssignmentMapping)
assignment = burgermenuportlet.Assignment()
chooser = INameChooser(manager)
assignment.path = '/'.join(context.getPhysicalPath())
manager[chooser.chooseName(None, assignment)] = assignment
id = context.getId()
object_Ids = []
catalog = getToolByName(context, 'portal_catalog')
brains = catalog.unrestrictedSearchResults(object_provides = IPilgrimageApp.__identifier__)
for brain in brains:
object_Ids.append(brain.id)
last_name = str(idnormalizer.normalize(context.title))
temp_new_id = last_name
new_id = temp_new_id.replace("-","")
test = ''
if new_id in object_Ids:
test = filter(lambda name: new_id in name, object_Ids)
if '-' not in (max(test)):
new_id = new_id + '-1'
if '-' in (max(test)):
new_id = new_id +'-' +str(int(max(test).split('-')[-1])+1)
parent.manage_renameObject(id, new_id )
new_title = last_name
context.setTitle(context.title)
context.reindexObject()
return
def handleSave(self, action):
data, errors = self.extractData()
if errors:
return False
types = api.portal.get_tool('portal_types')
type_info = types.getTypeInfo('eea.meeting.email')
name_chooser = INameChooser(self.context)
content_id = name_chooser.chooseName(data['subject'], self.context)
obj = type_info._constructInstance(self.context, content_id)
obj.title = data['subject']
obj.sender = data['sender']
obj.receiver = data['receiver']
obj.cc = data['cc']
obj.subject = data['subject']
obj.body = data['body']
obj.reindexObject()
notify(SendEmailAddEvent(self.context, data))
msg = _(u"Email successfully sent")
IStatusMessage(self.request).addStatusMessage(msg, type='info')
self.request.response.redirect(
self.context.getParentNode().absolute_url())
def copy(source=None, target=None, id=None, safe_id=False):
"""Copy the object to the target container.
:param source: [required] Object that we want to copy.
:type source: Content object
:param target: Target container to which the source object will
be moved. If no target is specified, the source object's container will
be used as a target.
:type target: Folderish content object
:param id: Id of the copied object on the target location. If no id is
provided, the copied object will have the same id as the source object
- however, if the new object's id conflicts with another object in the
target container, a suffix will be added to the new object's id.
:type id: string
:returns: Content object that was created in the target location
:param safe_id: When True, the given id will be enforced. If the id is
conflicting with another object in the target container, raise a
InvalidParameterError. When True, choose a new, non-conflicting id.
:type safe_id: boolean
:raises:
KeyError,
ValueError
:Example: :ref:`content_copy_example`
"""
source_id = source.getId()
target.manage_pasteObjects(source.manage_copyObjects(source_id))
if id:
if not safe_id:
new_id = id
else:
chooser = INameChooser(target)
new_id = chooser.chooseName(id, source)
target.manage_renameObject(source_id, new_id)
def choose_name(self):
if self._id is not None:
return self._id
title = self.arguments.get('title', self.portal_type)
chooser = INameChooser(self.container)
return chooser.chooseName(title, self.container)
def addUtility(root_folder, utility_type, utility_factory,
asObject=_marker, **kw):
""" Add a Utility to the root folder's site manager.
The utility is added to the default package and activated.
"""
if asObject is not _marker:
warnings.warn("asObject argument is deprecated and will be "
"removed in Zope 3.6", DeprecationWarning, 2)
package = getSiteManagerDefault(root_folder)
chooser = INameChooser(package)
utility = utility_factory()
name = chooser.chooseName(utility_type, utility)
package[name] = utility
# the utility might have been location-proxied; we need the name
# information (__name__) so let's get it back again from the
# container
utility = package[name]
# Set additional attributes on the utility
for k, v in kw.iteritems():
setattr(utility, k, v)
return utility
def _create_file(self, item, files, title, description, rights):
namechooser = INameChooser(self.context)
content_type = item.headers.get('Content-Type')
filename = safe_unicode(item.filename)
data = item.read()
id_name = ''
title = title and title[0] or filename
id_name = namechooser.chooseName(title, self.context)
if content_type in IMAGE_MIMETYPES:
portal_type = 'Image'
wrapped_data = NamedBlobImage(data=data, filename=filename)
else:
portal_type = 'File'
wrapped_data = NamedBlobFile(data=data, filename=filename)
self.context.invokeFactory(portal_type,
id=id_name,
title=title,
description=description[0],
rights=rights[0])
newfile = self.context[id_name]
if portal_type == 'File':
if IATFile.providedBy(newfile):
newfile.setFile(data, filename=filename)
else:
newfile.file = wrapped_data
elif portal_type == 'Image':
if IATImage.providedBy(newfile):
newfile.setImage(data, filename=filename)
else:
newfile.image = wrapped_data
newfile.reindexObject()
notify(ObjectModifiedEvent(newfile))
return newfile
def _createObject(context, event):
column = getUtility(IPortletManager, name=u'plone.leftcolumn', context=context)
manager = getMultiAdapter((context, column,), IPortletAssignmentMapping)
assignment = mydocs_portlet.Assignment()
chooser = INameChooser(manager)
assignment.button_label = 'My Documents'
manager[chooser.chooseName(None, assignment)] = assignment
def drop(self, mail):
""" drop a mail into this mail box. The mail is
a string with the complete email content """
# code unicode to utf-8
if isinstance(mail,unicode):
mail = mail.encode( 'utf-8' )
type = 'Email'
format = 'text/plain'
content_type='text/plain'
#generate title
mailobj = email.message_from_string(mail)
# Subject
for key in "Subject subject Betreff betreff".split():
subject = mailobj.get(key)
if subject:
subject = self.decodeheader(subject)
break
id = subject or DEFAULT_ID
title = id
# generate id
normalizer = component.getUtility(IIDNormalizer)
chooser = INameChooser(self.context)
id = chooser.chooseName(normalizer.normalize(id), aq_base(self.context))
self.context.invokeFactory(type ,id=id , title=title, format=format, \
content_type=content_type, file=mail)
getattr(self.context, id, None).setContentType(content_type)
getattr(self.context, id, None).processForm()
notify(MailDroppedEvent(getattr(self.context, id, None), self.context))
def add(self, schoolyear):
"""Add `schoolyear` to the container."""
chooser = INameChooser(self.context)
name = chooser.chooseName(schoolyear.title, schoolyear)
self.context[name] = schoolyear
self.importData(schoolyear)
return schoolyear
def __call__(self, name, content_type, data):
ctr = getToolByName(self.context, 'content_type_registry')
type_ = ctr.findTypeName(name.lower(), '', '') or 'File'
# otherwise I get ZPublisher.Conflict ConflictErrors
# when uploading multiple files
upload_lock.acquire()
name = safe_unicode(name)
chooser = INameChooser(self.context)
newid = chooser.chooseName(name, self.context.aq_parent)
try:
transaction.begin()
obj = ploneutils._createObjectByType(type_,
self.context, newid)
mutator = obj.getPrimaryField().getMutator(obj)
mutator(data, content_type=content_type, filename=name)
obj.setTitle(name)
if hasattr(obj, 'setFilename'):
# if chunk uploaded, needs override
obj.setFilename(name)
obj.reindexObject()
notify(ObjectInitializedEvent(obj))
notify(ObjectModifiedEvent(obj))
transaction.commit()
finally:
upload_lock.release()
return obj
def new_user(principal, event):
"""Initialise the dashboard for a new user
"""
defaults = IDefaultDashboard(principal, None)
if defaults is None:
return
userid = principal.getId()
portlets = defaults()
for name in ('plone.dashboard1', 'plone.dashboard2', 'plone.dashboard3', 'plone.dashboard4'):
assignments = portlets.get(name)
if assignments:
column = queryUtility(IPortletManager, name=name)
if column is not None:
category = column.get(USER_CATEGORY, None)
if category is not None:
manager = category.get(userid, None)
if manager is None:
manager = category[userid] = UserPortletAssignmentMapping(manager=name,
category=USER_CATEGORY,
name=userid)
chooser = INameChooser(manager)
for assignment in assignments:
manager[chooser.chooseName(None, assignment)] = assignment
def createNewDaviz(self):
""" Create new visualization
"""
davizsettings = queryUtility(IDavizSettings)
strFolder = davizsettings.settings.get("daviz.defaultfolder", "")
if strFolder != "":
portal = getSite()
folder = portal.restrictedTraverse(strFolder)
else:
folder = self.context.aq_parent
found = False
while True:
try:
allowedContentTypes = folder.allowedContentTypes()
except AttributeError:
break
for allowedContentType in allowedContentTypes:
if allowedContentType.id == "DavizVisualization":
found = True
if found:
break
folder = folder.aq_parent
if not found:
return
chooser = INameChooser(folder)
newId = chooser.chooseName(self.context.title, folder)
if newId in folder.objectIds():
raise NameError, 'Object id %s already exists' % newId
else:
folder.invokeFactory("DavizVisualization", newId)
newObj = folder[newId]
newObj.title = self.context.title
newObj.setRelatedItems([self.context])
self.request.response.redirect(newObj.absolute_url()+"/daviz-edit.html")
def add(self, course):
chooser = INameChooser(self.context)
name = chooser.chooseName(u'', course)
self.context[name] = course
self._course = course
if self._level is not None:
self._level.courses.add(course)
return course
def generate_id(name, context):
normalizer = component.getUtility(IIDNormalizer)
chooser = INameChooser(context)
normalized = normalizer.normalize(name)
normalized = normalized.replace('_', '-').replace(' ', '-').lower()
return chooser.chooseName(normalized, context)
def add(self, schedules):
self._objects_added = []
for section, schedule in self._objects_created:
schedules = IScheduleContainer(section)
chooser = INameChooser(schedules)
name = chooser.chooseName('', schedule)
schedules[name] = schedule
self._objects_added.append(schedule)
def _createProject(self):
""" Return newly created project, see _getProject. """
code = json.loads(self.payload)['code']
chooser = INameChooser(self.context)
project_id = chooser.chooseName(code, self.context)
self.context.invokeFactory("Project", project_id)
project = self.context[project_id]
project.setFromJSON(self.payload)
self._index = project.getJSON()
def _createProject(self):
""" Return newly created project, see _getProject. """
code = json.loads(self.payload)['code']
chooser = INameChooser(self.context)
project_id = chooser.chooseName(code, self.context)
self.context.invokeFactory("Project", project_id)
project = self.context[project_id]
project.setFromJSON(self.payload)
self._index = project.getJSON()
def add(self, content):
"""Add the rule to the context
"""
context = aq_inner(self.context)
manager = aq_base(context)
IPortletPermissionChecker(context)()
chooser = INameChooser(manager)
manager[chooser.chooseName(None, content)] = content
def createAndAdd(self, data):
resource = self._factory()
resource.title = data.get('title')
chooser = INameChooser(self.context)
resource.__name__ = chooser.chooseName('', resource)
form.applyChanges(self, resource, data)
notify(ObjectCreatedEvent(resource))
self.context[resource.__name__] = resource
self._resource = resource
return resource
def createAndAdd(self, data):
name = data['name']
description = data.get('description')
namechooser = INameChooser(self.context)
app = SampleApplication()
name = namechooser.chooseName(name, app)
app.name = name
app.description = description
self.context[name] = app
self.request.response.redirect(name)
def __call__(self, name, content_type, data):
ctr = getToolByName(self.context, 'content_type_registry')
type_ = ctr.findTypeName(name.lower(), content_type, data) or 'File'
name = name.decode('utf8')
chooser = INameChooser(self.context)
# otherwise I get ZPublisher.Conflict ConflictErrors
# when uploading multiple files
upload_lock.acquire()
newid = chooser.chooseName(name, self.context.aq_parent)
try:
transaction.begin()
# Try to determine which kind of NamedBlob we need
# This will suffice for standard p.a.contenttypes File/Image
# and any other custom type that would have 'File' or 'Image' in
# its type name
# XXX heuristics are harmful behavior, here a better implemenation
# is needed
filename = ploneutils.safe_unicode(name)
if 'Image' in type_:
image = NamedBlobImage(
data=data,
filename=filename,
contentType=content_type
)
obj = createContentInContainer(
self.context, type_,
id=newid,
image=image
)
else:
file = NamedBlobFile(
data=data,
filename=filename,
contentType=content_type
)
obj = createContentInContainer(
self.context,
type_,
id=newid,
file=file
)
obj.title = name
obj.reindexObject()
transaction.commit()
finally:
upload_lock.release()
return obj
def addDayTemplate(self, templates, day_key, day):
template = DayTemplate(title=day['title'])
templates[day_key] = template
name_chooser = INameChooser(template)
for item in day['time_slots']:
time_slot = TimeSlot(
item['tstart'], item['duration'],
activity_type=item['activity_type'])
key = name_chooser.chooseName('', time_slot)
template[key] = time_slot
def addPeriodTemplates(self, day_template_schedule, days):
for day_key, day_title, periods in days:
template = DayTemplate(title=day_title)
day_template_schedule.templates[day_key] = template
name_chooser = INameChooser(template)
for period_title, activity_type in periods:
period = Period(title=period_title,
activity_type=activity_type)
key = name_chooser.chooseName('', period)
template[key] = period
def addPortlet(context, columnName='plone.leftcolumn', portlet=None):
""" code borrowed from
https://github.com/collective/wm.sampledata/blob/3146f22bf82f60924766997b5106cf03b8cd27c8/wm/sampledata/utils.py
"""
if not portlet:
return
column = getUtility(IPortletManager, columnName)
manager = getMultiAdapter((context, column), IPortletAssignmentMapping)
chooser = INameChooser(manager)
manager[chooser.chooseName(None, portlet)] = portlet
def save_email(self):
email_type = "N/A"
if self.event.object.portal_type == 'eea.meeting.subscriber':
""" This is the case for approving a subscriber:
- Thank you for your registration
"""
meeting = self.event.object.aq_parent.aq_parent
state = self.event.object.subscriber_status()
if state == "approved":
email_type = u"Approval"
elif state == "rejected":
email_type = u"Rejection"
elif self.event.object.portal_type == 'eea.meeting':
""" This is the case for new subscriber registered:
- A new participant has registered to the meeting
- You have registered to the meeting
"""
meeting = self.event.object
email_type = u"Registration"
types = api.portal.get_tool('portal_types')
type_info = types.getTypeInfo('eea.meeting.email')
emails_folder = meeting['emails']
name_chooser = INameChooser(emails_folder)
interpolator = IStringInterpolator(self.event.object)
email_body = interpolator(self.element.message).strip()
recipients = interpolator(self.element.recipients).strip()
source = self.context.email_from_address
data = {
'subject': meeting.title,
'sender': source,
'receiver': recipients,
'cc': '',
'body': email_body,
'email_type': email_type,
}
content_id = name_chooser.chooseName(data['subject'], emails_folder)
obj = type_info._constructInstance(emails_folder, content_id)
obj.title = data['subject']
obj.sender = data['sender']
obj.receiver = data['receiver']
obj.cc = data['cc']
obj.subject = data['subject']
obj.body = data['body']
obj.email_type = data['email_type']
obj.reindexObject()
def ldap_added_subscriber(obj, event):
trst = Transcript()
app = grok.getApplication()
dbc = app.ldap_connection()
trst.dn = obj.dn
trst.before = u''
trst.after = unicode(obj.ldap_entry)
trst.observation_datetime = datetime.now()
trst.principal_id = obj.principal_id
namechooser = INameChooser( app['transcripts'] )
name = namechooser.chooseName('ldap_add', trst)
app['transcripts'][name] = trst
def add(self, content):
"""Add the rule to the context
"""
storage = getUtility(IRuleStorage)
chooser = INameChooser(storage)
name = chooser.chooseName(None, content)
self._chosen_name = name
storage[name] = content
IStatusMessage(self.request).add(_(
u'New content rule created. '
u'Please add conditions and actions at the bottom of the page.'),
type=u'info')
def create_document(container, document, zipfile):
temp_id = 'document.temp.{}'.format(randint(0, 999999))
id_ = container.invokeFactory('opengever.document.document', temp_id)
obj = container[id_]
# Mandatory metadata
metadata = {
'title': document.titles.title[0].value(),
}
# Optional metadata
if document.openingDate is not None:
metadata['document_date'] = document.openingDate
if document.owner is not None:
metadata['document_author'] = document.owner
if document.ourRecordReference is not None:
metadata['foreign_reference'] = document.ourRecordReference
if document.classification is not None:
metadata['classification'] = INV_CLASSIFICATION_MAPPING.get(
document.classification)
if document.hasPrivacyProtection is not None:
metadata['privacy_layer'] = INV_PRIVACY_LAYER_MAPPING.get(
document.hasPrivacyProtection)
if document.openToThePublic is not None:
metadata['public_trial'] = INV_PUBLIC_TRIAL_MAPPING.get(
document.openToThePublic)
if document.keywords:
metadata['keywords'] = [k.value() for k in document.keywords.keyword]
deserializer = queryMultiAdapter((obj, obj.REQUEST), IDeserializeFromJson)
deserializer(validate_all=True, data=metadata)
if document.files:
file_ = document.files.file[0]
try:
zipinfo = zipfile.getinfo(file_.pathFileName)
except KeyError:
raise ValueError('Missing file {}'.format(file_.pathFileName))
file_field = IDocumentSchema['file']
filename = os.path.basename(file_.pathFileName)
obj.file = file_field._type(data=zipfile.read(zipinfo),
contentType=file_.mimeType,
filename=filename)
# Rename document
chooser = INameChooser(container)
name = chooser.chooseName(None, obj)
transaction.savepoint(optimistic=True)
container.manage_renameObject(obj.getId(), name)
def create_object(self, folder, type_, info):
filename = info['name']
name = filename.decode("utf8")
chooser = INameChooser(folder)
chooser_name = name.lower().replace('aq_', '')
newid = chooser.chooseName(chooser_name, folder.aq_parent)
# strip metadata from file
if (type_ in ('Image', 'File', 'Video', 'Audio')
and exiftool is not None and 'tmp_file' in info):
try:
exiftool(info['tmp_file'])
except Exception:
logger.warn('Could not strip metadata from file: %s' %
info['tmp_file'])
fi = open(info['tmp_file'], 'r')
try:
# Try to determine which kind of NamedBlob we need
# This will suffice for standard p.a.contenttypes File/Image
# and any other custom type that would have 'File' or 'Image' in
# its type name
filename = ploneutils.safe_unicode(filename)
create_opts = dict(type=type_, id=newid, container=folder)
if 'Image' in type_:
image = NamedBlobImage(data=fi, filename=filename)
try:
image.focal_point = [
float(self.request.form.get('focalX')),
float(self.request.form.get('focalY'))
]
except Exception:
pass
create_opts['image'] = image
else:
create_opts['file'] = NamedBlobFile(data=fi, filename=filename)
for field in get_upload_fields():
if not field.get('name'):
continue
name = field['name']
if not self.request.form.get(name):
continue
if name in ('tags', 'subject'):
# tags needs to be converted
create_opts['subject'] = self.request.form.get(name).split(
';')
else:
create_opts[name] = self.request.form.get(name, '')
return api.content.create(**create_opts)
finally:
fi.close()
def addDayTemplate(self, templates, day_key, day):
period_map = {}
template = DayTemplate(title=day['title'])
templates[day_key] = template
name_chooser = INameChooser(template)
for item in day['periods']:
period = Period(title=item['title'],
activity_type=item['activity_type'])
key = name_chooser.chooseName('', period)
template[key] = period
period_map[(day['id'], item['title'])] = period
return BuildContext(period_map=period_map)
def get_new_unique_id(self, container):
''' This will get a new unique id according to the request
'''
form = self.request.form
title = self.title or form.get('title')
request_id = form.get('id')
chooser = INameChooser(container)
new_id = chooser.chooseName(
request_id or title,
container
)
return new_id
def createSection(self,
term,
course,
instructor,
periods,
section_id=None,
dry_run=True):
"""Create a section.
`periods` is a list of tuples (day_id, period_id).
A title is generated from the titles of `course` and `instructor`.
If an existing section with the same title is found, it is used instead
of creating a new one.
The created section is returned, or None if dry_run is True.
"""
if dry_run:
return None
sections = ISectionContainer(term)
section = Section()
chooser = INameChooser(sections)
auto_name = chooser.chooseName('', section)
section.title = u"%s (%s)" % (course.title, auto_name)
if section_id is None:
section_id = auto_name
sections[section_id] = section
# Establish links to course and to teacher
if course not in section.courses:
section.courses.add(course)
if instructor not in section.instructors:
section.instructors.add(instructor)
timetable_container = ITimetableContainer(self.schoolyear)
timetables = [timetable_container[ttid] for ttid in sorted(periods)]
schedules = IScheduleContainer(section)
for timetable in timetables:
selected = periods[timetable.__name__]
schedule = SelectedPeriodsSchedule(timetable,
term.first,
term.last,
title=timetable.title,
timezone=timetable.timezone)
for period in selected:
schedule.addPeriod(period)
schedules[timetable.__name__] = schedule
return section
def handleApply(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
self.applyChanges(data)
self.context.collective_immediatecreate = "created"
# rename
chooser = INameChooser(aq_parent(self.context))
new_id = chooser.chooseName(None, self.context)
api.content.rename(obj=self.context, new_id=new_id)
api.portal.show_message(self.success_message, self.request)
self.request.response.redirect(self.nextURL())
notify(EditFinishedEvent(self.context))
def ensureAtLeastOneWorksheet(worksheets, factory=None, title=None):
# only create new worksheet if no personal
# worksheet (hidden or not) is found
for worksheet in worksheets.all_worksheets:
if not worksheet.deployed:
return
if factory is None:
factory = Worksheet
if title is None:
title = _('Sheet1')
sheet1 = factory(title)
chooser = INameChooser(worksheets)
name = chooser.chooseName('', sheet1)
worksheets[name] = sheet1
def setupPortletAt(portal, portlet_type, manager, path, name="", **kw):
"""
setupPortletAt(portal, 'portlets.Events', 'plone.rightcolumn', '/vereinigungen/fachliche-vereinigungen/sektion-kondensierte-materie/halbleiterphysik') # noqa
"""
portlet_factory = getUtility(IFactory, name=portlet_type)
assignment = portlet_factory(**kw)
mapping = assignment_mapping_from_key(
portal, manager, CONTEXT_CATEGORY, path, create=True
)
if not name:
chooser = INameChooser(mapping)
name = chooser.chooseName(None, assignment)
mapping[name] = assignment
def upload(self, files, title='', description=''):
loaded = []
namechooser = INameChooser(self.context)
if not isinstance(files, list):
files = [files]
for item in files:
if item.filename:
content_type = item.headers.get('Content-Type')
filename = safe_unicode(item.filename)
data = item.read()
id_name = ''
title = title and title[0] or filename
# Get a unique id here
id_name = namechooser.chooseName(title, self.context)
# Portal types allowed : File and Image
# Since Plone 4.x both types use Blob
if content_type in IMAGE_MIMETYPES:
portal_type = 'Image'
wrapped_data = NamedBlobImage(data=data, filename=filename)
else:
portal_type = 'File'
wrapped_data = NamedBlobFile(data=data, filename=filename)
# Create content
self.context.invokeFactory(portal_type,
id=id_name,
title=title,
description=description[0])
newfile = self.context[id_name]
# Set data
if portal_type == 'File':
if IATFile.providedBy(newfile):
newfile.setFile(data)
else:
newfile.file = wrapped_data
elif portal_type == 'Image':
if IATImage.providedBy(newfile):
newfile.setImage(data)
else:
newfile.image = wrapped_data
# Finalize content creation, reindex it
newfile.reindexObject()
notify(ObjectModifiedEvent(newfile))
loaded.append(newfile)
if loaded:
return loaded
return False
def create_dossier(container, dossier, zipfile, responsible):
temp_id = 'dossier.temp.{}'.format(randint(0, 999999))
id_ = container.invokeFactory('opengever.dossier.businesscasedossier',
temp_id)
obj = container[id_]
# Mandatory metadata
metadata = {
'title': dossier.titles.title[0].value(),
'responsible': responsible,
}
# Optional metadata
if dossier.openingDate is not None:
metadata['start'] = dossier.openingDate
if dossier.classification is not None:
metadata['classification'] = INV_CLASSIFICATION_MAPPING.get(
dossier.classification)
if dossier.hasPrivacyProtection is not None:
metadata['privacy_layer'] = INV_PRIVACY_LAYER_MAPPING.get(
dossier.hasPrivacyProtection)
if dossier.keywords is not None:
metadata['keywords'] = [k.value() for k in dossier.keywords.keyword]
if dossier.comments is not None:
metadata['comments'] = u'\n'.join(
[k.value() for k in dossier.comments.comment])
deserializer = queryMultiAdapter((obj, obj.REQUEST), IDeserializeFromJson)
deserializer(validate_all=True,
data=sanitize_metadata(metadata),
create=True)
# Rename dossier
chooser = INameChooser(container)
name = chooser.chooseName(None, obj)
transaction.savepoint(optimistic=True)
container.manage_renameObject(obj.getId(), name)
if dossier.dossiers:
for subdossier in dossier.dossiers.dossier:
create_dossier(obj, subdossier, zipfile, responsible)
if dossier.documents:
for document in dossier.documents.document:
create_document(obj, document, zipfile)
def create_title_from_id(obj, event):
if not api.portal.get_registry_record(
'ploneintranet.workspace.rename_after_title_changed',
default=True,
):
return
autosave_portal_types = api.portal.get_registry_record(
'ploneintranet.workspace.autosave_portal_types',
default=[],
)
if obj.portal_type in autosave_portal_types:
# autosave does not work well with autorename because the form action
# will point to the old URL and the redirection tool will not work
# with the ajax calls
return
if IContainerModifiedEvent.providedBy(event):
# The container modified event gets triggered during the creation
# of a folder. We must not change the id before an item as been
# properly created.
return
if IBaseWorkspaceFolder.providedBy(obj):
# Don't change the ID of a workspace
return
if not in_workspace(obj):
# Don't handle content outside of a workspace
return
orig_id = obj.getId()
title_adapter = INameFromTitle(obj, None)
name = title_adapter and title_adapter.title
if not name:
# No title present, no point in changing the id
return
if len(name) > MAX_ID_FROM_TITLE_LENGTH:
plone_view = getMultiAdapter((obj, obj.REQUEST), name='plone')
name = plone_view.cropText(name, MAX_ID_FROM_TITLE_LENGTH, ellipsis="")
normalized_name = IUserPreferredURLNormalizer(obj.REQUEST).normalize(name)
container = aq_parent(obj)
# Check if the id is already looking good
if _is_id_good_enough(orig_id, normalized_name, container):
return
chooser = INameChooser(container)
new_id = chooser and chooser.chooseName(normalized_name, container)
if new_id and new_id != orig_id:
unlock_view = obj.restrictedTraverse('@@toggle-lock', None)
if unlock_view and unlock_view.can_unlock():
unlock_view.unlock()
api.content.rename(obj, new_id)
def send(self, sender=None, recipients=None):
self.sender = sender
if recipients is not None:
self.recipients = recipients
self.updated_on = self.utcnow
app = ISchoolToolApplication(None)
messages = IMessageContainer(app)
if self.__name__:
if (self.__name__ in messages):
if (sameProxiedObjects(messages[self.__name__], self)):
return # already sent
del messages[self.__name__]
messages[self.__name__] = self
else:
name_chooser = INameChooser(messages)
name = name_chooser.chooseName('', self)
messages[name] = self
def add_site_record(self, site_record):
orig_name = site_record.id
chooser = INameChooser(self)
try:
chooser.checkName(orig_name, site_record)
except KeyError:
# the name already exists, no problem, we're just going to
# increment it anyway
pass
except (TypeError, ValueError):
msg = "%s is not useable as a name for a site record" % orig_name
raise ValueError(msg)
name = chooser.chooseName(orig_name, site_record)
checkObject(self, name, site_record)
site_record.id = name
self[name] = site_record
return name
def ldap_modified_subscriber(obj, event):
# XXX the way we jam principal.id into the temporary User object
# works, but it don't feel right at all. Is there a way to look-up
# the request from an event?!?
trst = Transcript()
app = grok.getApplication()
dbc = app.ldap_connection()
trst.dn = obj.dn
try:
trst.before = unicode(app['users'][obj.__name__].ldap_entry)
except KeyError:
trst.before = u''
trst.after = unicode(obj.ldap_entry)
trst.observation_datetime = datetime.now()
trst.principal_id = obj.principal_id
namechooser = INameChooser( app['transcripts'] )
name = namechooser.chooseName('ldap_mod', trst)
app['transcripts'][name] = trst
def copyTemplate(self, source, title):
target = aq_inner(self.context)
try:
source._notifyOfCopyTo(target, op=0)
except ConflictError:
raise
copy = source._getCopy(target)
copy.title = title
chooser = INameChooser(target)
copy.id = chooser.chooseName(None, copy)
target._setObject(copy.id, copy)
copy = target[copy.id] # Acquisition-wrap
copy.wl_clearLocks()
copy._postCopy(target, op=0)
notify(ObjectClonedEvent(target[copy.id]))
return copy
def install_plone3_portlets(self):
"""Add all portlets to the right column in the portal root.
Other variations are possible:
- At least do this for the cart portlet as that one always makes
sense.
- Assign the one correct portlet for an object at the moment that
we make it buyable, donatable, etc.
- When setting a content type as payable in the control panel,
assign the correct portlet to that content type.
"""
# Do the imports here, as we only need them here
from zope.container.interfaces import INameChooser
from zope.component import getUtility, getMultiAdapter
from plone.portlets.interfaces import IPortletManager, IPortletAssignmentMapping
from Products.PloneGetPaid.browser import portlets
# Get some definitions.
portal = self.portal_url.getPortalObject()
column = getUtility(IPortletManager,
name="plone.rightcolumn",
context=portal)
manager = getMultiAdapter((portal, column), IPortletAssignmentMapping)
portletnames = [v.title for v in manager.values()]
chooser = INameChooser(manager)
assignments = [
portlets.cart.Assignment(),
portlets.buy.Assignment(),
portlets.donate.Assignment(),
portlets.variableamountdonate.Assignment(),
portlets.recurring.Assignment(),
portlets.ship.Assignment(),
portlets.premium.Assignment(),
]
for assignment in assignments:
title = assignment.title
if title not in portletnames:
manager[chooser.chooseName(title, assignment)] = assignment
def importAllTimetables(self):
if not self.shouldImportAllTimetables():
return
oldTimetables = ITimetableContainer(self.activeSchoolyear)
newTimetables = ITimetableContainer(self.newSchoolyear)
chooser = INameChooser(newTimetables)
app = ISchoolToolApplication(None)
tzname = IApplicationPreferences(app).timezone
for schooltt in oldTimetables.values():
newSchooltt = Timetable(self.newSchoolyear.first,
self.newSchoolyear.last,
title=schooltt.title,
timezone=tzname)
name = chooser.chooseName(schooltt.__name__, newSchooltt)
newTimetables[name] = newSchooltt
self.setUpTimetable(newSchooltt, schooltt)
if (oldTimetables.default is not None
and sameProxiedObjects(oldTimetables.default, schooltt)):
newTimetables.default = newSchooltt
def createSubscription(self,
to=None,
for_=None,
when=None,
owner_id=None,
permission_id=None,
dialect_id=None):
subscription = self._new_Subscription(to=to,
for_=for_,
when=when,
owner_id=owner_id,
permission_id=permission_id,
dialect_id=dialect_id)
name_chooser = INameChooser(self)
name = name_chooser.chooseName('', subscription) # pylint:disable=too-many-function-args,assignment-from-no-return
self[name] = subscription
self.activateSubscription(subscription)
return subscription
def rename_object(self, obj):
# Archetypes objects may get renamed during deserialization.
# Do not rename again.
if (base_hasattr(obj, '_isIDAutoGenerated')
and not obj._isIDAutoGenerated(obj.getId())):
return
chooser = INameChooser(self.context)
# INameFromTitle adaptable objects should not get a name
# suggestion. NameChooser would prefer the given name instead of
# the one provided by the INameFromTitle adapter.
suggestion = None
name_from_title = INameFromTitle(obj, None)
if name_from_title is None:
if base_hasattr(obj, 'generateNewId'):
suggestion = obj.generateNewId()
else:
suggestion = obj.Title()
name = chooser.chooseName(suggestion, obj)
transaction.savepoint(optimistic=True)
self.context.manage_renameObject(obj.getId(), name)
