def test_tile_creation(self):
tile = TestTile(
url='http://nohost/plone/test-document/@@my.tile/firstTile',
id='firstTile',
context=self.document,
request=self.request)
self.assertEqual(getattr(self.document, 'tiles_list', None), None)
notify(ObjectAddedEvent(tile, self.document, tile.id))
resStructure = {
'defaultManager': [
{
'tile_type': 'my.tile',
'tile_id': 'firstTile',
'tile_hidden': False,
'tile_style': '',
},
],
}
self.assertEqual(self.document.tiles_list, resStructure)
tile2 = TestTile(
url='http://nohost/plone/test-document/@@alt.tile/secondTile',
id='secondTile',
context=self.document,
request=self.request)
notify(ObjectAddedEvent(tile2, self.document, tile2.id))
resStructure['defaultManager'].append({
'tile_type': 'alt.tile',
'tile_id': 'secondTile',
'tile_hidden': False,
'tile_style': '',
})
self.assertEqual(self.document.tiles_list, resStructure)
def setUp(self):
"""Custom shared utility setup for tests."""
self.portal = self.layer['portal']
self.request = self.layer['request']
self.installer = api.portal.get_tool('portal_quickinstaller')
setRoles(self.portal, TEST_USER_ID, ['Manager'])
api.user.create(
username='******',
email='*****@*****.**',
password='******',
)
api.user.create(
username='******',
email='*****@*****.**',
password='******',
)
setRoles(self.portal, 'editor', ['Editor', 'Contributor'])
setRoles(self.portal, 'member', ['Member'])
self.document = api.content.create(type='Document',
title='Test document',
container=self.portal)
# create two tiles
tile = TestTile(
url='http://nohost/plone/test-document/@@my.tile/firstTile',
id='firstTile',
context=self.document,
request=self.request)
tile2 = TestTile(
url='http://nohost/plone/test-document/@@alt.tile/secondTile',
id='secondTile',
context=self.document,
request=self.request)
notify(ObjectAddedEvent(tile, self.document, 'firstTile'))
notify(ObjectAddedEvent(tile2, self.document, 'secondTile'))
def create_task(parent, **kwargs):
createContent('opengever.task.task')
task = createContent('opengever.task.task', **kwargs)
notify(ObjectCreatedEvent(task))
task = addContentToContainer(parent, task, checkConstraints=False)
notify(ObjectAddedEvent(task))
return task
def add(self, item):
if not IResponse.providedBy(item):
raise ValueError("IResponse interface not provided.")
self.append(item)
id = str(len(self))
event = ObjectAddedEvent(item, newParent=self.context, newName=id)
notify(event)
def test_multilanguage_indexer(self):
portal_catalog = api.portal.get_tool("portal_catalog")
utility = queryUtility(ITaxonomy, name="collective.taxonomy.test")
taxonomy = utility.data
taxonomy_test = schema.Set(
title=u"taxonomy_test",
description=u"taxonomy description schema",
required=False,
value_type=schema.Choice(
vocabulary=u"collective.taxonomy.taxonomies"),
)
portal_types = api.portal.get_tool("portal_types")
fti = portal_types.get("Document")
document_schema = fti.lookupSchema()
schemaeditor = IEditableSchema(document_schema)
schemaeditor.addField(taxonomy_test, name="taxonomy_test")
notify(ObjectAddedEvent(taxonomy_test, document_schema))
notify(FieldAddedEvent(fti, taxonomy_test))
query = {}
query["taxonomy_test"] = "5"
taxo_val = taxonomy["en"][u"\u241fInformation Science\u241fSport"]
self.document.taxonomy_test = [taxo_val]
self.document.reindexObject()
self.assertEqual(len(portal_catalog(query)), 1)
# clean up
schemaeditor.removeField("taxonomy_test")
def set_uid(obj, uid):
if hasattr(aq_base(obj), '_setUID'):
obj._setUID(uid)
else:
setattr(obj, plone.uuid.interfaces.ATTRIBUTE_NAME, uid)
notify(ObjectAddedEvent(obj))
def _fire_event(self, context, event):
if event == "modified":
event = ObjectModifiedEvent(context)
elif event == "added":
event = ObjectAddedEvent(context)
if event:
zope.event.notify(event)
def add_document(self, data, properties, request=None):
"""Add new document"""
if request is None:
request = check_request()
registry = request.registry
# check required properties
properties = properties.copy()
title = properties.get('title')
application_name = properties.get('application_name')
if (not title) or (not application_name) or (data is None):
raise HTTPBadRequest("Missing arguments")
owner = properties.get('owner')
if owner and not request.has_permission(
CREATE_DOCUMENT_WITH_OWNER_PERMISSION, context=self):
raise HTTPForbidden()
if not owner:
properties['owner'] = request.principal.id
properties['creator'] = request.principal.id
# check storage folders
folder = self._get_folder(datetime.utcnow())
# create document and first version
document, version = self._create_document(registry, folder)
# update document data and properties
version.update(data, properties)
# store document
document.get_oid()
folder[document.oid] = document
registry.notify(ObjectAddedEvent(version, folder, document.oid))
# return
return version
def create_testobject(parent, ptype, **kwargs):
createContent(ptype)
obj = createContent(ptype, **kwargs)
notify(ObjectCreatedEvent(obj))
obj = addContentToContainer(parent, obj, checkConstraints=False)
notify(ObjectAddedEvent(obj))
return obj
def add(self, field):
context = self.context
schema = IEditableSchema(context.schema)
# move it after the last field that is not in a fieldset
# or at top if there is no field yet in "default" fieldset
ordered_fields = [name for (name, f) in sortedFields(context.schema)]
default_fields = non_fieldset_fields(context.schema)
if len(default_fields) > 0:
position = ordered_fields.index(default_fields[-1]) + 1
else:
position = 0
try:
schema.addField(field)
except ValueError:
raise WidgetActionExecutionError('__name__',
Invalid(
u'Please select a field name that is not already used.'
))
schema.moveField(field.__name__, position)
notify(ObjectAddedEvent(field, context.schema))
notify(FieldAddedEvent(context, field))
IStatusMessage(self.request).addStatusMessage(
_(u"Field added successfully."), type='info')
def _createFolderStructure(self, folder, structure='ymd', date=None):
""" Create a folder structure and then return our innermost folder
"""
if not date:
date = DateTime()
dateFormat = structure
date = date.strftime(dateFormat)
folderStructure = [str(p) for p in date.split('/')]
container = self.element.container
language = folder.Language()
# We run IRuleExecutor here to make sure other rules will be
# executed for the newly created folders
executor = IRuleExecutor(self.context, None)
for fId in folderStructure:
if not fId in folder.objectIds():
_createObjectByType(container,
folder,
id=fId,
title=fId,
description=fId)
folder = folder[fId]
# this makes happy multilang sites
folder.setLanguage(language)
event = ObjectAddedEvent(folder, aq_parent(folder), fId)
if executor is not None:
executor(event)
else:
folder = folder[fId]
return folder
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
typeName = self.tileType.__name__
generator = getUtility(IUUIDGenerator)
tileId = generator()
# Traverse to a new tile in the context, with no data
tile = self.context.restrictedTraverse('@@%s/%s' % (
typeName,
tileId,
))
dataManager = ITileDataManager(tile)
dataManager.set(data)
# Look up the URL - we need to do this after we've set the data to
# correctly account for transient tiles
tileURL = absoluteURL(tile, self.request)
notify(ObjectCreatedEvent(tile))
notify(ObjectAddedEvent(tile, self.context, tileId))
self.request.response.redirect(tileURL)
def test_multilanguage_indexer(self):
portal_catalog = api.portal.get_tool('portal_catalog')
utility = queryUtility(ITaxonomy, name='collective.taxonomy.test')
taxonomy = utility.data
taxonomy_test = schema.Set(
title=u"taxonomy_test",
description=u"taxonomy description schema",
required=False,
value_type=schema.Choice(
vocabulary=u"collective.taxonomy.taxonomies"),
)
portal_types = api.portal.get_tool('portal_types')
fti = portal_types.get('Document')
document_schema = fti.lookupSchema()
schemaeditor = IEditableSchema(document_schema)
schemaeditor.addField(taxonomy_test, name='taxonomy_test')
notify(ObjectAddedEvent(taxonomy_test, document_schema))
notify(FieldAddedEvent(fti, taxonomy_test))
query = {}
query['taxonomy_test'] = '5'
simple_tax = [val for val in taxonomy['en'].values()]
taxo_val = simple_tax[3]
self.document.taxonomy_test = [taxo_val]
self.document.reindexObject()
self.assertEqual(len(portal_catalog(query)), 1)
def testIgnoreAddedEvents(self):
class Content(object):
__parent__ = None
__name__ = None
handlers.modified(ObjectAddedEvent(Content()))
self.assertFalse(self.called)
def __call__(self, filename, title, description, content_type, data,
portal_type):
if filename.lower().endswith('msg'):
# its a outlook msg file
# needs to be converted by the Msg2MimeTransform
data = Msg2MimeTransform()(data)
filename = filename.replace('msg', 'eml')
portal_type = self.get_portal_type(filename)
obj = createContentInContainer(self.context, portal_type)
named_file = self.create_file(filename, data, obj)
self.set_default_values(obj, named_file)
# initalize digitaly available
notify(ObjectCreatedEvent(obj))
# start pdf conversion
notify(ObjectAddedEvent(obj))
# rest of initialization
notify(ObjectModifiedEvent(obj))
obj.reindexObject()
result = {}
result['success'] = obj
return result
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
typeName = self.tileType.__name__
context = self.context
# Look up if our context supports tiles, if not
# pick default view instead
if not ILayoutAware(context, None):
default_page_view = getMultiAdapter((context, self.request),
name='default_page')
default_page = default_page_view.getDefaultPage()
context = default_page and context[default_page] or context
context = ILayoutAware(context, None)
# Traverse to a new tile in the context, with no data
tile = context.restrictedTraverse(
'@@%s/%s' % (typeName, self.tileId,))
dataManager = ITileDataManager(tile)
dataManager.set(data)
# Look up the URL - we need to do this after we've set the data to
# correctly account for transient tiles
tileURL = absoluteURL(tile, self.request)
contextURL = absoluteURL(tile.context, self.request)
tileRelativeURL = tileURL
if tileURL.startswith(contextURL):
tileRelativeURL = '.' + tileURL[len(contextURL):]
notify(ObjectCreatedEvent(tile))
notify(ObjectAddedEvent(tile, self.context, self.tileId))
IStatusMessage(self.request).addStatusMessage(
_(u"Tile created at ${url}",
mapping={'url': tileURL}),
type=u'info',
)
# Calculate the edit URL and append some data in a JSON structure,
# to help the UI know what to do.
url = getEditTileURL(tile, self.request)
tileDataJson = {}
tileDataJson['action'] = "save"
tileDataJson['mode'] = "add"
tileDataJson['url'] = tileRelativeURL
tileDataJson['tile_type'] = typeName
tileDataJson['id'] = tile.id
url = appendJSONData(url, 'tiledata', tileDataJson)
self.request.response.redirect(url)
def indexLinks(event):
iids = getUtility(IIntIds)
for link in event.getLinks():
link = removeSecurityProxy(link)
addIntIdSubscriber(link, ObjectAddedEvent(link))
lid = iids.getId(link)
getLinkCatalog().index_doc(lid, link)
link.__parent__._lids.add(lid)
def test_gets_fired_on_mail_added(self):
self.login(self.regular_user)
register_event_recorder(IObjectTouchedEvent)
notify(ObjectAddedEvent(self.mail_eml))
event = get_last_recorded_event()
self.assertTrue(IObjectTouchedEvent.providedBy(event))
def test_no_marker(self):
context = FauxContext(FauxContainer(), 'new')
notify(ObjectModifiedEvent(context))
notify(ObjectAddedEvent(context))
notify(ObjectRemovedEvent(context))
self.assertEquals(0, len(self.handler.invocations))
def test_not_purged(self):
context = FauxNonContent('new').__of__(FauxContent())
notify(ObjectModifiedEvent(context))
notify(ObjectAddedEvent(context))
notify(ObjectRemovedEvent(context))
self.assertEqual(0, len(self.handler.invocations))
def getGroupContainer(sy):
addIntIdSubscriber(sy, ObjectAddedEvent(sy))
int_ids = getUtility(IIntIds)
sy_id = str(int_ids.getId(sy))
app = ISchoolToolApplication(None)
gc = app['schooltool.group'].get(sy_id, None)
if gc is None:
gc = app['schooltool.group'][sy_id] = GroupContainer()
return gc
def test_CategoriesUpToDateWithEvents(self):
from quotationtool.categorization.category import Category
cat1 = Category()
cat1.__name__ = u"cat1"
from zope.lifecycleevent import ObjectAddedEvent, ObjectRemovedEvent
zope.event.notify(ObjectAddedEvent(cat1))
self.assertTrue(self.categories.getCategory(u'cat1') is cat1)
zope.event.notify(ObjectRemovedEvent(cat1))
self.assertTrue(self.categories.getCategory(u'cat1') == None)
def test_integration_object_events(self):
""" Trigger every event of a objec at least one times
and check the journalentries.
"""
dossier1 = create(Builder('dossier'))
dossier2 = create(Builder('dossier'))
document = create(
Builder('document').within(dossier1).titled(u'Document'))
document2 = create(
Builder('document').within(dossier2).titled(u'Document'))
notify(
ObjectMovedEvent(
document,
dossier1,
'oldName',
dossier2,
'newName',
))
self.check_annotation(
dossier1,
action_type='Object moved',
action_title='Object moved: %s' % document.title_or_id(),
)
# Test that a normal ObjectAddedEvent does not result in an object
# moved journal entry.
notify(ObjectAddedEvent(document2))
entry1 = get_journal_entry(dossier2, entry=-1)
entry2 = get_journal_entry(dossier2, entry=-2)
self.assertTrue(entry1.get('action').get('type') != 'Object moved')
self.assertTrue(entry2.get('action').get('type') != 'Object moved')
notify(
ObjectWillBeMovedEvent(
document,
dossier1,
'oldName',
dossier2,
'newName',
))
self.check_annotation(dossier1,
action_type='Object cut',
action_title='Object cut: %s' %
document.title_or_id())
# Here we don't have a journal-entry
length = get_journal_length(dossier1)
notify(ObjectWillBeAddedEvent(
document,
dossier2,
'newName',
))
self.assertTrue(length == get_journal_length(dossier1))
def _createFolderStructure(self, folder, structure='ymd', date=None):
""" Create a folder structure and then return our innermost folder
"""
if not date:
date = DateTime()
dateFormat = structure
if '%B' in dateFormat:
translation = getToolByName(self.context, 'translation_service')
PLMF = MessageFactory('plonelocales')
dateFormat = dateFormat.replace('%B', '%m')
date = date.strftime(dateFormat)
folderStructure = [str(p) for p in date.split('/')]
index = dateFormat.split('/').index('%m')
month_msgid = PLMF(translation.month_msgid(folderStructure[index]))
try:
target_language = i18n.negotiate(self.context.REQUEST)
except:
target_language = None
transale_month = translate(month_msgid,
target_language=target_language)
folderStructure[index] = transale_month
else:
date = date.strftime(dateFormat)
folderStructure = [str(p) for p in date.split('/')]
container = self.element.container
language = folder.Language()
normalizer = getUtility(IIDNormalizer)
portal_workflow = getToolByName(self.context, 'portal_workflow')
pw = portal_workflow.doActionFor
# We run IRuleExecutor here to make sure other rules will be
# executed for the newly created folders
executor = IRuleExecutor(self.context, None)
for fId in folderStructure:
fTitle = fId
fId = normalizer.normalize(fId)
if not fId in folder.objectIds():
_createObjectByType(container,
folder,
id=normalizer.normalize(fId),
title=fTitle,
description=fTitle)
folder = folder[fId]
pw(folder, 'publish')
# this makes happy multilang sites
folder.setLanguage(language)
event = ObjectAddedEvent(folder, aq_parent(folder), fId)
if executor is not None:
executor(event)
else:
folder = folder[fId]
return folder
def add(self, link):
if link.__parent__ == self:
raise ValueError("You are adding same link twice.")
i = 1
while "%s" % i in self._links:
i += 1
link.__name__ = "%s" % i
self._links[link.__name__] = link
link.__parent__ = self
notify(ObjectAddedEvent(link, self._links, link.__name__))
def bootstrapSchoolTool(self, db):
"""Bootstrap SchoolTool database."""
connection = db.open()
root = connection.root()
app_obj = root.get(ZopePublication.root_name)
if app_obj is None:
app = SchoolToolApplication()
# Run school specific initialization code
initializationUtility = getUtility(
ISchoolToolInitializationUtility)
initializationUtility.initializeApplication(app)
directlyProvides(app, directlyProvidedBy(app) + IContainmentRoot)
root[ZopePublication.root_name] = app
# savepoint to make sure that the app object has
# a _p_jar. This is needed to make things like
# KeyReference work, which in turn is needed to
# make the catalog work. We make this savepoint
# optimistic because it will then work with any registered
# data managers that do not support this feature.
transaction.savepoint(optimistic=True)
# set up the site so that local utility setups and catalog
# indexing would work properly
if not ISite.providedBy(app):
app.setSiteManager(LocalSiteManager(app))
setSite(app)
# We must set up the int ids utility before setting up any
# of the plugin specific catalogs, as catalogs rely on
# IntIds being present
setUpUtilities(app, [UtilitySpecification(IntIds, IIntIds)])
# tell plugins to initialize their catalogs, must be done
# before initializing plugins themselves or else all the
# initial groups, persons, resources will not get indexed
notify(CatalogSetUpEvent(app))
notify(CatalogStartUpEvent(app))
# initialize plugins themselves
notify(ApplicationInitializationEvent(app))
notify(ObjectAddedEvent(app))
# unset the site so we would not confuse other
# bootstraping code
setSite(None)
self.restoreManagerUser(app, MANAGER_PASSWORD)
self.initializePreferences(app)
transaction.commit()
connection.close()
def render(self):
data = self.request.get('data', None)
assert data is not None, 'Bad request: no delivery data found'
data = json.loads(data)
if self.is_already_delivered(data):
# Set correct content type for text response
self.request.response.setHeader("Content-type", "tex/plain")
return 'OK'
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event
# handler from creating additional responses per added document.
self.request.set('X-CREATING-SUCCESSOR', True)
# Create the delivered documents:
transporter = getUtility(ITransporter)
documents = []
message = _(u'version_message_resolved_task',
default=u'Document copied from task (task resolved)')
if data.get('transition'
) == 'task-transition-in-progress-tested-and-closed':
message = _(u'version_message_closed_task',
default=u'Document copied from task (task closed)')
with CustomInitialVersionMessage(message, self.context.REQUEST):
for item in encode_after_json(data['documents']):
doc = transporter._create_object(self.context, item)
# append `RE:` prefix to the document title
doc.title = '%s: %s' % (translate(
_(u'answer_prefix', default=u'RE'),
context=self.context.REQUEST), doc.title)
documents.append(doc)
notify(ObjectAddedEvent(doc))
# Change workflow state of predecessor task:
util.change_task_workflow_state(self.context,
data['transition'],
text=data['text'],
added_object=documents)
# Set correct content type for text response
self.request.response.setHeader("Content-type", "tex/plain")
return 'OK'
def test(self):
from schooltool.app.security import authSetUpSubscriber
self.assertRaises(ComponentLookupError, self.app.getSiteManager)
event = ObjectAddedEvent(self.app)
authSetUpSubscriber(self.app, event)
auth = traverse(self.app, '++etc++site/default/SchoolToolAuth')
auth1 = getUtility(IAuthentication, context=self.app)
self.assert_(auth is auth1)
# If we fire the event again, it does not fail. Such events
# are fired when the object is copied and pasted.
authSetUpSubscriber(self.app, event)
def __call__(self):
data = self.request.get('data', None)
assert data is not None, 'Bad request: no delivery data found'
data = json.loads(data)
if self.is_already_delivered(data):
return ok_response()
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event
# handler from creating additional responses per added document.
self.request.set('X-CREATING-SUCCESSOR', True)
# Create the delivered documents:
transporter = Transporter()
documents = []
message = _(
u'version_message_resolved_task',
default=u'Document copied from task (task resolved)')
if data.get(
'transition') == 'task-transition-in-progress-tested-and-closed':
message = _(
u'version_message_closed_task',
default=u'Document copied from task (task closed)')
for item in data['documents']:
doc = transporter.create(item, self.context)
Versioner(doc).set_custom_initial_version_comment(message)
# append `RE:` prefix to the document title
doc.title = '%s: %s' % (
translate(
_(u'answer_prefix', default=u'RE'),
context=self.context.REQUEST),
doc.title)
documents.append(doc)
notify(ObjectAddedEvent(doc))
# Change workflow state of predecessor task:
util.change_task_workflow_state(
self.context, data['transition'], text=data['text'],
added_object=documents)
return ok_response()
def getBoundContact(context):
person = IBasicPerson(removeSecurityProxy(context))
annotations = IAnnotations(person)
contact = annotations.get(PERSON_CONTACT_KEY, None)
if contact is None:
contact = BoundContact()
annotations[PERSON_CONTACT_KEY] = contact
contact.__name__ = 'contact'
contact.__parent__ = person
dependable = IDependable(contact)
dependable.addDependent("")
notify(ObjectAddedEvent(contact, contact.__parent__, contact.__name__))
return contact