def saveJobProgress(event):
""" Save job progress
"""
portal = getToolByName(event.object, 'portal_url').getPortalObject()
portal_anno = IAnnotations(portal)
annotation = portal_anno.get('async_move_jobs')
annotation_job = annotation.setdefault(event.job_id, {})
if event.operation == 'initialize':
annotation_job['sub_progress'] = {}
operation_type = getattr(event, 'operation_type', 'Moved')
annotation_job['title'] = "%s below objects within: %s" % (
operation_type, event.object.absolute_url()
)
for oid, title in event.oblist_id:
annotation_job['sub_progress'][oid] = {}
annotation_job['sub_progress'][oid]['progress'] = 0
annotation_job['sub_progress'][oid]['title'] = title
if event.operation == 'sub_progress':
obj_id = event.obj_id
annotation_job.setdefault('sub_progress', {})
annotation_job['sub_progress'].setdefault(obj_id, {})
annotation_job['sub_progress'][obj_id]['progress'] = event.progress
if event.operation == 'progress':
annotation_job['progress'] = event.progress
def cleanup_convert_figure_jobs(context):
""" Cleanup Async jobs saved on EEAFIgureFile
"""
ctool = getToolByName(context, 'portal_catalog')
brains = ctool.unrestrictedSearchResults(portal_type=['EEAFigureFile'])
logger.info('Removing async jobs')
count = 0
for brain in brains:
try:
doc = brain.getObject()
if getattr(doc, '_convertjob', None):
del doc._convertjob
try:
anno = IAnnotations(doc)
except TypeError:
continue
convert_job = anno.get('convert_figure_job')
if convert_job and not isinstance(convert_job, dict):
del anno['convert_figure_job']
else:
continue
logger.info('Removing async for %s', brain.getURL())
count += 1
if count % 100 == 0:
logger.info('INFO: Transaction committed to zodb %s', count)
transaction.commit()
except Exception, err:
logger.warn('Couldn\'t remove async for %s', brain.getURL())
# ctool.uncatalog_object(brain.getPath())
logger.exception(err)
continue
def import_oggbundle(app, args):
"""Handler for the 'bin/instance import' zopectl command.
"""
setup_logging()
bundle_path = sys.argv[3]
log.info("Importing OGGBundle %s" % bundle_path)
plone = setup_plone(get_first_plone_site(app))
# mark request with GEVER layer
alsoProvides(plone.REQUEST, IOpengeverBaseLayer)
# Don't use a separate ZODB connection to issue sequence numbers in
# order to avoid conflict errors during OGGBundle import
alsoProvides(plone.REQUEST, INoSeparateConnectionForSequenceNumbers)
transmogrifier = Transmogrifier(plone)
IAnnotations(transmogrifier)[BUNDLE_PATH_KEY] = bundle_path
with DisabledLDAP(plone):
transmogrifier(u'opengever.bundle.oggbundle')
bundle = IAnnotations(transmogrifier)[BUNDLE_KEY]
timings = bundle.stats['timings']
duration = timings['done_post_processing'] - timings['start_loading']
log.info("Duration: %.2fs" % duration.total_seconds())
log.info("Committing transaction...")
transaction.get().note("Finished import of OGGBundle %r" % bundle_path)
transaction.commit()
log.info("Done.")
def after_resolve_jobs_pending(self):
"""This flag tracks whether these jobs have already been executed for
a resolved dossier, or are still pending (because they have been
deferred to a nightly job).
"""
ann = IAnnotations(self.context)
return ann.get(AFTER_RESOLVE_JOBS_PENDING_KEY, False)
def _annotation_storage(self, create_if_missing=False):
annotations = IAnnotations(self.context)
# Avoid writes on read
if REMINDER_ANNOTATIONS_KEY not in annotations and create_if_missing:
annotations[REMINDER_ANNOTATIONS_KEY] = PersistentDict()
return annotations.get(REMINDER_ANNOTATIONS_KEY, {})
def disable_behaviors(obj, behaviors, ifaces):
""" Disable behaviors on an object.
:param obj: The Dexterity content object to disable behaviors on.
:type obj: object
:param behaviors: Behaviors to be disabled on the object. This is a list of
dotted names of behavior schema interfaces.
:type behaviors: list
:param ifaces: Behavior marker interfaces belonging to the behaviors to be
disabled. This is a list of interface classes.
:type ifaces: class
Use it like so:
>>> from plone.app.event.dx.interfaces import IDXEvent
>>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
... [IDXEvent,])
"""
annotations = IAnnotations(obj)
instance_behaviors = annotations.get(KEY, ())
instance_behaviors = filter(lambda x: x not in behaviors,
instance_behaviors)
annotations[KEY] = instance_behaviors
for iface in ifaces:
noLongerProvides(obj, iface)
obj.reindexObject(idxs=('object_provides'))
def __call__(self, *args, **kw):
context = self.context
request = self.request
request.set('disable_border', 1)
# following two only on Plone 4+
request.set('disable_plone.leftcolumn', 1)
request.set('disable_plone.rightcolumn', 1)
self.error = False
token = request.form.get('token')
path = request.form.get('path')
comment = request.form.get('comment', None)
doc = context.unrestrictedTraverse(path)
conf = IAnnotations(doc).get('share-tokens')
if conf.get('reject') and conf.get(
'reject') == token and not comment.strip():
# comment when rejecting is required
context.plone_utils.addPortalMessage(
_(u'When rejecting, a motivation is required'), type='error')
request.response.redirect(
request.form.get('came_from') or context.absolute_url())
return
try:
self.result = ConsumePowerTokenView.__call__(self,
comment=comment,
**kw)[0]
except PowerTokenSecurityError:
self.result = None
self.error = True
return self.index()
def __init__(self, context):
self.ideal_wrapper = getUtility(IMollieIdeal)
annotations = IAnnotations(context)
self._metadata = annotations.get(IDEAL_PAYMENT_ANNOTATION_KEY, None)
if self._metadata is None:
self._metadata = PersistentMapping()
annotations[IDEAL_PAYMENT_ANNOTATION_KEY] = self._metadata
def test_cktemplate_moved(self):
oemf = self.portal['templates']['oem']
srvf = self.portal['contacts']['plonegroup-organization']
org1 = srvf['direction-generale']
org2 = srvf['direction-generale']['secretariat']
self.assertIn(org1.UID(), oemf)
self.assertIn(org2.UID(), oemf)
mod1 = api.content.create(container=oemf,
type='cktemplate',
id='mod1',
title='Modèle 1')
annot = IAnnotations(mod1)
self.assertEqual(annot['dmsmail.cke_tpl_tit'], u'')
mod1 = api.content.move(mod1, oemf[org1.UID()])
annot = IAnnotations(mod1)
self.assertEqual(annot['dmsmail.cke_tpl_tit'], u'Direction générale')
mod2 = api.content.copy(mod1, oemf[org2.UID()], id='mod2')
annot = IAnnotations(mod2)
self.assertEqual(annot['dmsmail.cke_tpl_tit'],
u'Direction générale - Secrétariat')
folder = api.content.create(container=oemf,
type='Folder',
id='fold1',
title='héhéhé')
mod2 = api.content.move(mod2, folder)
annot = IAnnotations(mod2)
self.assertEqual(annot['dmsmail.cke_tpl_tit'], u'héhéhé')
mod2 = api.content.rename(mod2, 'mod-nextgen')
annot = IAnnotations(mod2)
self.assertEqual(annot['dmsmail.cke_tpl_tit'], u'héhéhé')
def __call__(self, *args, **kw):
context = self.context
request = self.request
request.set('disable_border', 1)
# following two only on Plone 4+
request.set('disable_plone.leftcolumn', 1)
request.set('disable_plone.rightcolumn', 1)
self.error = False
token = request.form.get('token')
path = request.form.get('path')
comment = request.form.get('comment', None)
doc = context.unrestrictedTraverse(path)
conf = IAnnotations(doc).get('share-tokens')
if conf.get('reject') and conf.get('reject')==token and not comment.strip():
# comment when rejecting is required
context.plone_utils.addPortalMessage(_(u'When rejecting, a motivation is required'),
type='error')
request.response.redirect(request.form.get('came_from') or context.absolute_url())
return
try:
self.result = ConsumePowerTokenView.__call__(self, comment=comment, **kw)[0]
except PowerTokenSecurityError:
self.result = None
self.error = True
return self.index()
class BasicProfile(object):
implements(IBasicProfile)
adapts(IPrincipal)
def __init__(self, principal):
self.annotations = IAnnotations(principal)
self.principal = principal
@setproperty
def name(self, v):
self.annotations['name'] = v
# for principalfolder search
ip = internal_principal(self.principal.id)
ip.title = v
@getproperty
def name(self):
return self.annotations.get('name', self.principal.title)
@setproperty
def email(self, v):
self.annotations['email'] = v
@getproperty
def email(self):
return self.annotations.get('email', u'')
def count_dataset_created(obj, event):
# IBLobDataset
# IRemoteDataset
# IDatasetCollection -> IMultiSpeciesDataset
if IAnnotations(obj.REQUEST).get('org.bccvl.site.stats.delay'):
# skip this event, we have been called from transmogrify chain, where
# we collect stats later
# tell stats collector that we really created a new object
IAnnotations(obj.REQUEST)['org.bccvl.site.stats.created'] = True
return
dataSrc = obj.dataSource
if not dataSrc:
if obj.part_of:
# part of multispecies file ... get dataSource from master file
master = uuidToObject(obj.part_of)
dataSrc = master.dataSource
if not dataSrc:
# find default
# check whether we are inside an experiment:
if defaults.EXPERIMENTS_FOLDER_ID in obj.getPhysicalPath():
dataSrc = 'experiment'
else:
dataSrc = 'upload'
getUtility(IStatsUtility).count_dataset(source=dataSrc,
portal_type=obj.portal_type)
def get_slid(self):
"""slideshare slideshowid or redirect to upload"""
annotations = IAnnotations(self.context)
sl_id = annotations.get(KEY, None)
if sl_id:
return sl_id
else:
if IATFile.providedBy(self.context):
if self.context.getContentType() in SLIDES_MIMETYPES:
self.request.response.redirect(
self.context.absolute_url() +
'/@@slideshare_post.html')
else:
msg = _(u"This file does not seem to be a presentation")
IStatusMessage(self.request).addStatusMessage(msg,
type='error')
elif IATLink.providedBy(self.context):
urlob = urlparse(self.context.getRemoteUrl())
if urlob.hostname == 'www.slideshare.net':
self.request.response.redirect(
self.context.absolute_url() +
'/@@slideshare_getid.html')
else:
msg = _(u"This is not a valid slideshare URL")
IStatusMessage(self.request).addStatusMessage(msg,
type='error')
def _default_stylebook(self):
if not getattr(self, '_default', None):
if not [o.getId() for o in self.stylebooks()]:
return None
anno = IAnnotations(self.context).get(ANNO_KEY, {})
self._default = anno.get('default_stylebook', None)
return self._default
def import_oggbundle(app, args):
"""Handler for the 'bin/instance import' zopectl command.
"""
setup_logging()
# Discard the first three arguments, because they're not "actual" arguments
# but cruft that we get because of the way bin/instance [zopectl_cmd]
# scripts work.
args = parse_args(sys.argv[3:])
log.info("Importing OGGBundle %s" % args.bundle_path)
plone = setup_plone(get_first_plone_site(app))
# mark request with GEVER layer
alsoProvides(plone.REQUEST, IOpengeverBaseLayer)
# Don't use a separate ZODB connection to issue sequence numbers in
# order to avoid conflict errors during OGGBundle import
alsoProvides(plone.REQUEST, INoSeparateConnectionForSequenceNumbers)
# Add index to track imported GUIDs (if it doesn't exist yet)
add_guid_index()
transmogrifier = Transmogrifier(plone)
ann = IAnnotations(transmogrifier)
ann[BUNDLE_PATH_KEY] = args.bundle_path
ann[INTERMEDIATE_COMMITS_KEY] = not args.no_intermediate_commits
solr_enabled = api.portal.get_registry_record(
'opengever.base.interfaces.ISearchSettings.use_solr', default=False)
if solr_enabled:
# Check if solr is running
conn = getUtility(ISolrConnectionManager).connection
if conn.get('/schema').status == -1:
raise Exception(
"Solr isn't running, but solr reindexing is enabled. "
"Skipping solr reindexing via `--skip-solr`.")
else:
# Disable collective indexing as it can lead to too many
# subtransactions
unpatch_collective_indexing()
with DisabledLDAP(plone):
transmogrifier(u'opengever.bundle.oggbundle')
bundle = IAnnotations(transmogrifier)[BUNDLE_KEY]
timings = bundle.stats['timings']
if 'migration_finished' in timings:
duration = timings['migration_finished'] - timings['start_loading']
log.info("Duration: %.2fs" % duration.total_seconds())
log.info("Committing transaction...")
transaction.get().note("Finished import of OGGBundle %r" %
args.bundle_path)
transaction.commit()
log.info("Done.")
def registerPersistentConfig(site, type_):
""" Try to get persistent pipeline configuration of given type (export or import)
and register it for use with transmogrifier.
"""
global CONFIGFILE
anno = IAnnotations(site)
key = '%s.%s' % (ANNOKEY, type_)
config = anno.has_key(key) and anno[key] or None
# unregister old config
name = 'persitent-%s' % type_
if name in configuration_registry._config_ids:
configuration_registry._config_ids.remove(name)
del configuration_registry._config_info[name]
# register new
if config is not None:
title = description = u'Persistent %s pipeline'
tf = tempfile.NamedTemporaryFile('w+t', suffix='.cfg')
tf.write(config)
tf.seek(0)
CONFIGFILE = tf
configuration_registry.registerConfiguration(name, title, description, tf.name)
return name
else:
return None
def is_available(self, obj, data_type='preview'):
if data_type == 'pdf':
annotations = IAnnotations(obj)
if annotations.get(PDF_VERSION_KEY):
return True
else:
return False
def _getHandle(self, context):
"""
Helper method looking up the handle in the context's annotation.
Returns None if not existing.
"""
annotations = IAnnotations(context)
return annotations.get(KEY, None)
def get_users_statistics_reports(site):
""" Get existing reports saved in annotations
"""
annotations = IAnnotations(site)
reports = annotations.get(USERS_STATISTICS_KEY, None)
return reports
def get_statuses(self, create_if_missing=False):
"""Get the mapping of delivery statuses by transport.
"""
ann = IAnnotations(self.disposition)
if TRANSPORT_STATUSES_KEY not in ann and create_if_missing:
ann[TRANSPORT_STATUSES_KEY] = PersistentMapping()
return ann.get(TRANSPORT_STATUSES_KEY, {})
def disable_behaviors(obj, behaviors, ifaces, reindex=True):
""" Disable behaviors on an object.
:param obj: The Dexterity content object to disable behaviors on.
:type obj: object
:param behaviors: Behaviors to be disabled on the object. This is a list of
dotted names of behavior schema interfaces.
:type behaviors: list or tuple
:param ifaces: Behavior marker interfaces belonging to the behaviors to be
disabled. This is a list of interface classes.
:type ifaces: class
:param reindex: Flag whether to reindex object after modification
:type reindex: bool
Use it like so:
>>> from plone.app.event.dx.interfaces import IDXEvent
>>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
... [IDXEvent,])
"""
annotations = IAnnotations(obj)
instance_behaviors = annotations.get(ANNOTATION_KEY, ())
instance_behaviors = filter(lambda x: x not in behaviors,
instance_behaviors)
annotations[ANNOTATION_KEY] = instance_behaviors
for iface in ifaces:
noLongerProvides(obj, iface)
if reindex:
obj.reindexObject(idxs=('object_provides'))
class BasicProfile(object):
implements(IBasicProfile)
adapts(IPrincipal)
def __init__(self, principal):
self.annotations = IAnnotations(principal)
self.principal = principal
@setproperty
def name(self, v):
self.annotations['name'] = v
# for principalfolder search
ip = internal_principal(self.principal.id)
ip.title = v
@getproperty
def name(self):
return self.annotations.get('name', self.principal.title)
@setproperty
def email(self, v):
self.annotations['email'] = v
@getproperty
def email(self):
return self.annotations.get('email', u'')
def __iter__(self):
for item in self.previous:
keys = item.keys()
pathkey = self.pathkey(*keys)[0]
objpath = item[pathkey]
obj = self.context.unrestrictedTraverse(objpath)
# The contructor generated an empty object (which triggered our
# stats event handler.) Let's update the stats here manually.
created = IAnnotations(obj.REQUEST).get(
'org.bccvl.site.stats.created', False)
if created:
# our created subscriber has been invoked
getUtility(IStatsUtility).count_dataset(
source=obj.dataSource, portal_type=obj.portal_type)
# reset the flag ... we can do that, because the pipeline runs
# sequentially
IAnnotations(
obj.REQUEST)['org.bccvl.site.stats.created'] = False
# Attach a job tracker only for species dataset from multispecies
if item.get('_partof', {}):
jt = IJobTracker(obj)
jt.new_job('TODO: generate id',
'generate taskname: ala_import',
function=obj.dataSource,
type=obj.portal_type,
state='COMPLETED')
yield item
def has_metadata_changed_been_filled():
site = getSite()
annotations = IAnnotations(site)
if METADATA_CHANGED_FILLED_KEY not in annotations:
# This is a newly setup deployment or one where the first upgrade has not been run.
return True
return bool(annotations.get(METADATA_CHANGED_FILLED_KEY))
def setUp(self):
super(TestReceiveDocumentPDF, self).setUp()
self.document = create(
Builder('document').titled(
u'\xdcberpr\xfcfung XY')).as_shadow_document()
IAnnotations(self.document)[PDF_SAVE_TOKEN_KEY] = self.save_token
IAnnotations(self.document)[PDF_SAVE_OWNER_ID_KEY] = self.user.userid
def __call__(self):
form = self.request.form
context = aq_inner(self.context)
annotations = IAnnotations(context)['collective.pfg.payment']
if form.get("form.button.UpdateNumber", None) is not None:
sdm = getToolByName(context, 'session_data_manager')
session = sdm.getSessionData(create=False)
if session is not None:
if session.get('collective.pfg.payment.number', None) is not None:
del session['collective.pfg.payment.number']
re = getUtility(IRegularExpression)
numbering_type = form.get('numbering_type')
if numbering_type == 'Incremental':
annotations.numbering_type = 'Incremental'
next_incremental_number = form.get('next_incremental_number', None)
if re.integer(next_incremental_number):
annotations.next_incremental_number = int(next_incremental_number)
else:
message = _(u"Please input integer number for the incremental number.")
IStatusMessage(self.request).addStatusMessage(message, type='warn')
elif numbering_type == 'Random':
annotations.numbering_type = 'Random'
random_number_digits = form.get('random_number_digits', None)
if re.integer(random_number_digits):
annotations.random_number_digits = int(random_number_digits)
else:
message = _(u"Please input integer number for the randome digits.")
IStatusMessage(self.request).addStatusMessage(message, type='warn')
return self.template()
def patched_getScale(self, instance, scale):
""" return scaled and aq-wrapped version for given image data """
field = self.context
available = field.getAvailableSizes(instance)
if scale in available or scale is None:
image = self.retrieveScale(instance, scale=scale)
if not image: # create the scale if it doesn't exist
width, height = available[scale]
data = self.createScale(instance, scale, width, height)
if data is not None:
self.storeScale(instance, scale, **data)
image = self.retrieveScale(instance, scale=scale)
# retrieve scale width and height from annotation for image that has
# missing info, this happens when we get the svg scale
if image and not image.width:
width, height = available[scale]
annotations = IAnnotations(instance)
scale_annotations = annotations.get('plone.scale')
filename = image.getFilename()
for value in scale_annotations.values():
scale_key = value.get('key')
scale_height = scale_key[1][1]
scale_width = scale_key[2][1]
if scale_height == height and scale_width == width and \
filename == value.get('filename'):
image.width = value.get('width')
image.height = value.get('height')
break
if image is not None and not isinstance(image, basestring):
return image
return None
def handle(self):
"""
Looks up the handle in the context's annotation.
Returns None if not found.
"""
annotations = IAnnotations(self.context)
return annotations.get(KEY, None)
def __init__(self, context):
self.context = self.__parent__ = context # see PvWh book site 269
annotations = IAnnotations(context)
mapping = annotations.get(EntryNavAnnotations_KEY)
if mapping is None:
mapping = annotations[EntryNavAnnotations_KEY] = PersistentDict({'name': '', 'order': 0})
self.mapping = mapping
def __init__(self, context):
self.context = context
self.portal = getToolByName(self.context, 'portal_url').getPortalObject()
storage = IAnnotations(self.portal)
if not storage.has_key(STORAGE_KEY):
storage[STORAGE_KEY] = PersistentDict()
self.storage = storage[STORAGE_KEY]
def update_opengraphable_objects(context, new_ct):
g_marker = queryUtility(IOpengraphMarkerUtility)
if not g_marker:
return
options = IAnnotations(context)
ct = getToolByName(context, 'portal_catalog')
olds_pt = options.get('old_content_types', [])
if new_ct == olds_pt:
return
adds = []
for new in new_ct:
if new in olds_pt:
olds_pt.remove(new)
else:
adds.append(new)
nb_items, bad_items = g_marker.update(context, adds, olds_pt)
updated = u'%d %s' % (nb_items, _(u'objects updated.'))
if not bad_items:
message = updated
else:
message = u'%s, %d %s: %s' % (updated,
len(bad_items),
_(u'update(s) on object(s) failed'),
','.join(bad_items), )
pu = getToolByName(context, 'plone_utils')
pu.addPortalMessage(message)
def test_customstyles_are_stored_in_btree(self):
adapter = ICustomStyles(self.portal)
adapter.set('css.body-background', 'blue')
annotations = IAnnotations(self.portal)
self.assertEquals(OOBTree,
type(annotations.get(CUSTOMSTYLES_ANNOTATION_KEY)))
def _getHandle(self, context):
"""
Helper method looking up the handle in the context's annotation.
Returns None if not existing.
"""
annotations = IAnnotations(context)
return annotations.get(KEY, None)
def handle(self):
"""
Looks up the handle in the context's annotation.
Returns None if not found.
"""
annotations = IAnnotations(self.context)
return annotations.get(KEY, None)
def get_users_statistics_reports(site):
""" Get existing reports saved in annotations
"""
annotations = IAnnotations(site)
reports = annotations.get(USERS_STATISTICS_KEY, None)
return reports
def disable_behaviors(obj, behaviors, ifaces):
""" Disable behaviors on an object.
:param obj: The Dexterity content object to disable behaviors on.
:type obj: object
:param behaviors: Behaviors to be disabled on the object. This is a list of
dotted names of behavior schema interfaces.
:type behaviors: list
:param ifaces: Behavior marker interfaces belonging to the behaviors to be
disabled. This is a list of interface classes.
:type ifaces: class
Use it like so:
>>> from plone.app.event.dx.interfaces import IDXEvent
>>> disable_behaviors(obj, ['plone.app.event.dx.behaviors.IEventBasic',],
... [IDXEvent,])
"""
annotations = IAnnotations(obj)
instance_behaviors = list(annotations.get(KEY, []))
instance_behaviors = filter(lambda x: x not in behaviors,
instance_behaviors)
annotations[KEY] = instance_behaviors
for iface in ifaces:
noLongerProvides(obj, iface)
# TODO UNTESTED:
obj.reindexObject(idxs=('object_provides'))
def get_table_filters():
"""get_table_filters."""
site = getSite()
anno = IAnnotations(site)
matrix = anno.get('matrix_1', {})
return matrix.get('select_categories', {})
def after_resolve_jobs_pending(self):
"""This flag tracks whether these jobs have already been executed for
a resolved dossier, or are still pending (because they have been
deferred to a nightly job).
"""
ann = IAnnotations(self.context)
return ann.get(AFTER_RESOLVE_JOBS_PENDING_KEY, False)
class NotificationConfiglet(BrowserView):
template = ViewPageTemplateFile('configlet.pt')
def __call__(self, delete=None):
self.storage = IAnnotations(self.context)
if delete and self.storage.has_key(STORAGE_KEY) and self.storage[STORAGE_KEY].has_key(delete):
del self.storage[STORAGE_KEY][delete]
statusmessages = IStatusMessage(self.request)
statusmessages.addStatusMessage(_('message_deleted', default='Notification template deleted'), type='info')
return self.template()
@memoize
def templates(self):
if not self.storage.has_key(STORAGE_KEY):
return []
templates_raw = self.storage.get(STORAGE_KEY)
vocabulary = availableWorkflows(self.context)
templates = []
for name, template in templates_raw.items():
template = {'name': name,
'template': template}
try:
term = vocabulary.getTermByToken(name)
template.update(dict(title=(term.title or term.token)))
except:
pass
templates.append(template)
return templates
def queue(self):
queue = getattr(self, "_queue", None)
if queue is None:
annotations = IAnnotations(self.context)
if not annotations.has_key(self.key):
annotations[self.key] = IOBTree()
self._queue = annotations[self.key]
return self._queue
def test_setData_stores_data(self):
annotations = IAnnotations(self.layer['portal'])
self.assertIsNone(annotations.get(ANNOTATION_KEY))
component = getAdapter(self.layer['portal'], IDataCollector,
name='ftw.servicenavigation')
component.setData(EXAMPLE_DATA)
self.assertEqual(EXAMPLE_DATA, annotations[ANNOTATION_KEY])
def _migrate_related_items_annotations(self):
query = {'portal_type': 'opengever.document.document',
'object_provides': IHasRelations.__identifier__}
for obj in self.objects(query, 'Migrate relatedItems annotations'):
ann = IAnnotations(obj)
if OLD_KEY in ann:
ann[NEW_KEY] = ann[OLD_KEY]
ann.pop(OLD_KEY)
def instance_behaviors_of(obj):
"""Return applied instance behavior names of object.
:param obj: The Dexterity content object to enable behaviors on.
:type obj: object
"""
annotations = IAnnotations(obj)
return annotations.get(ANNOTATION_KEY, ())
def get_payment_data(self):
adapted = IAnnotations(self.context)
payment_code = self.request.SESSION.get(MIPAGO_PAYMENT_CODE, None)
if payment_code is not None:
payments = adapted.get(ANNOTATION_KEY, {})
return payments.get(payment_code, None)
return None
def post(self, **kwargs):
""" POST
"""
newids = self.request.get('new_ids')
newtitles = self.request.get('new_titles', '')
paths = self.request.get('paths', '')
if 'form.button.Cancel' in kwargs:
return self._redirect(_(u"Rename cancelled"), redirect_to='')
elif 'form.button.rename' in kwargs:
return self.original_action(action='rename')
elif 'form.button.async_rename' in kwargs:
return self.index()
worker = getUtility(IAsyncService)
queue = worker.getQueues()['']
email = api.user.get_current().getProperty('email')
try:
job = worker.queueJobInQueue(
queue, (ASYNCMOVE_QUEUE,),
async_rename,
self.context,
new_ids=newids,
new_titles=newtitles,
paths=paths,
success_event=AsyncRenameSuccess,
fail_event=AsyncRenameFail,
email=email
)
job_id = u64(job._p_oid)
context = self.context
wrapper = IContextWrapper(context)(
folder_move_from=context.absolute_url(1),
folder_move_to=', '.join(newids),
folder_move_objects=', '.join(paths),
asyncmove_email=email,
async_operation_type='rename',
email=email
)
notify(AsyncOperationAdded(wrapper))
anno = IAnnotations(self.context)
anno['async_move_job'] = job_id
portal = getToolByName(self, 'portal_url').getPortalObject()
portal_anno = IAnnotations(portal)
if not portal_anno.get('async_move_jobs'):
portal_anno['async_move_jobs'] = OOBTree()
message_type = 'info'
message = _(u"Item added to the queue. "
u"We will notify you by email at '%s' when the job is "
u"completed" % email)
except Exception, err:
logger.exception(err)
message_type = 'error'
message = u"Failed to add items to the sync queue"
def store(self, conf):
self.check_permission(conf)
annotations = IAnnotations(self.context)
storage = annotations.get(SL_ANNOTATION_KEY, None)
if storage:
storage.update(make_resursive_persistent(conf))
else:
annotations[SL_ANNOTATION_KEY] = make_resursive_persistent(conf)
def uninstall(context):
if context.readDataFile('raptus.notification.uninstall.txt') is None:
return
portal = context.getSite()
# Remove notification storage to prevent broken object errors after removal
storage = IAnnotations(portal)
if storage.get(ANNOTATIONS_KEY, None) is not None:
del storage[ANNOTATIONS_KEY]
def storage(self):
obj = self.config.get_annotated_object()
ann = IAnnotations(obj)
key = self.config.get_annotations_key()
if key not in ann.keys():
ann[key] = PersistentDict()
return ann[key]
def storage(self):
annotations = IAnnotations(self.context)
scales = annotations.setdefault('plone.scale', ScalesDict())
if not isinstance(scales, ScalesDict):
# migrate from PersistentDict to ScalesDict
new_scales = ScalesDict(scales)
annotations['plone.scale'] = new_scales
return new_scales
return scales
def getInfoByRevision(self, instance, name, rev):
""" Get info about a storage item by a give revision
"""
annotations = IAnnotations(instance)
if not annotations.has_key(LOG_KEY) or \
not annotations[LOG_KEY].has_key(name) or \
not annotations[LOG_KEY][name].has_key(rev):
return
return annotations[LOG_KEY][name][rev]
def test_setData_stores_data(self):
annotations = IAnnotations(self.layer['portal'])
self.assertIsNone(annotations.get(ANNOTATION_KEY))
component = getAdapter(self.layer['portal'],
IDataCollector,
name='ftw.servicenavigation')
component.setData(EXAMPLE_DATA)
self.assertEqual(EXAMPLE_DATA, annotations[ANNOTATION_KEY])
def storage(self):
obj = self.config.get_annotated_object()
ann = IAnnotations(obj)
key = self.config.get_annotations_key()
if key not in ann.keys():
ann[key] = PersistentDict()
return ann[key]
def async_move(context, success_event, fail_event, **kwargs):
""" Async job
"""
newid = kwargs.get('newid', '')
email = kwargs.get('email', '')
anno = IAnnotations(context)
job_id = anno.get('async_move_job')
if not newid:
wrapper = IContextWrapper(context)(
error=u'Invalid newid'
)
notify(fail_event(wrapper))
raise CopyError(eNoItemsSpecified)
try:
_op, mdatas = _cb_decode(newid)
except:
raise CopyError(eInvalid)
oblist = []
app = context.getPhysicalRoot()
for mdata in mdatas:
m = loadMoniker(mdata)
try:
ob = m.bind(app)
except ConflictError:
raise
except:
raise CopyError(eNotFound)
oblist.append(ob)
wrapper = IContextWrapper(context)(
folder_move_from=oblist and aq_parent(
aq_inner(oblist[0])).absolute_url(),
folder_move_to=context.absolute_url(),
folder_move_objects=', '.join([obj.getId() for obj in oblist]),
asyncmove_email=email
)
try:
manage_pasteObjects_no_events(context, cb_copy_data=newid)
except Exception, err:
logger.exception(err)
wrapper.error = err.message
wrapper.job_id = job_id
notify(fail_event(wrapper))
raise CopyError(MessageDialog(
title='Error',
message=err.message,
action='manage_main',
))
def _initialize(self, create=False):
if self.storage is not None:
return
storage = IAnnotations(self.context)
if storage.get(ANNOTATIONS_KEY, None) is None:
storage[ANNOTATIONS_KEY] = dict.PersistentDict()
storage[ANNOTATIONS_KEY]['notifications'] = IOBTree()
storage[ANNOTATIONS_KEY]['user'] = OOBTree()
storage[ANNOTATIONS_KEY]['intid'] = 1
self.storage = storage.get(ANNOTATIONS_KEY, None)
def __call__(self):
disable_edit_bar()
annotations = IAnnotations(self.context)
self.source_document = uuidToObject(annotations.get(PDF_SAVE_SOURCE_UUID_KEY))
self.version_id = annotations.get(PDF_SAVE_SOURCE_VERSION_KEY)
self.destination_document = self.context
self.destination = self.context.get_parent_dossier()
self.trigger_conversion()
return self.template()
def update(self):
form = self.request.form
if form.get("form.button.UseLocalPayment") is not None:
res = form.get("local_payment")
numbers = IAnnotations(self.context)['collective.pfg.payment']
if res is True or res == 'on':
numbers.local_payment = True
else:
numbers.local_payment = False
self.request.response.redirect(self.current_url)
