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 test_ParentsAreCorrectlyUpdatedOnMove(self): # first create some projects and sub-projects using the _createProjectsAndTestAnnotationsEvolution (project1, subproject1, subSubproject1, subSubproject2, project1Annotations, subproject1Annotations, subSubproject1Annotations, subSubproject2Annotations) = self._createProjectsAndTestAnnotationsEvolution() project2 = self.portal.projectspace['project-2'] project2Annotations = IAnnotations(project2) # we change initial state self.pw.doActionFor(project2, "set_to_be_scheduled") params = {'title': 'Subproject 2', 'priority': 'priority-2', } subproject2 = createContentInContainer(project2, 'project', **params) # we change initial state self.pw.doActionFor(subproject2, "set_to_be_scheduled") subproject2Annotations = IAnnotations(subproject2) # verifying content self.assertEquals(len(project1Annotations[CBIAK].keys()), 3) self.assertEquals(len(subproject1Annotations[CBIAK].keys()), 2) self.assertDictEqual(project2Annotations.get(CBIAK, {}), {}) self.assertDictEqual(subproject2Annotations.get(CBIAK, {}), {}) # we move last level api.content.move(subSubproject2, subproject2) self.assertEquals(len(project1Annotations[CBIAK].keys()), 2) self.assertEquals(len(subproject1Annotations[CBIAK].keys()), 1) self.assertEquals(len(project2Annotations[CBIAK].keys()), 1) self.assertEquals(len(subproject2Annotations[CBIAK].keys()), 1) # we move intermediate level api.content.move(subproject1, project2) self.assertEquals(len(project1Annotations[CBIAK].keys()), 0) self.assertEquals(len(subproject1Annotations[CBIAK].keys()), 1) self.assertEquals(len(project2Annotations[CBIAK].keys()), 3) self.assertEquals(len(subproject2Annotations[CBIAK].keys()), 1)
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 __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 _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()
class MegaphoneRenderer(BrowserView): """ This is a view of a Megaphone action which renders the letter based on the request form variables and the template stored in an annotation on the form folder. """ def __init__(self, context, request): self.context = context self.request = request self.data = IAnnotations(context).get(ANNOTATION_KEY, PersistentDict()) def render_letter(self, request=None): if request is None: request = self.request transformer = getToolByName(self.context, 'portal_transforms') template = self.data.get('template', '${sender_body}') return transformer( 'web_intelligent_plain_text_to_html', _dreplace(template, self.context, request) ) def render_plaintext_letter(self): template = self.data.get('template', '${sender_body}') return _dreplace(template, self.context, self.request).encode('utf8') def render_all_letters(self): letters = [] for request in recipient_multiplexer(self.context, self.request): letters.append(self.render_letter(request=request)) return letters def render_thankyou(self): transformer = getToolByName(self.context, 'portal_transforms') template = self.data.get('thankyou_template', '') return transformer( 'web_intelligent_plain_text_to_html', _dreplace(template, self.context, self.request) ) def render_recipient_source_snippets(self): out = [] for _, source in getAdapters((self.context, self.request), IRecipientSource): out.append(source.render_form()) return ''.join(out) def render_recipients_list(self): recipients = [] for _, source in getAdapters((self.context, self.request), IRecipientSource): for recipient in source.lookup(): recipients.append(recipient_label(recipient)) return recipients
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 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 __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 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 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 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 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 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 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)
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 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 _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 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 _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 = 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 __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 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 _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_table_filters(): """get_table_filters.""" site = getSite() anno = IAnnotations(site) matrix = anno.get('matrix_1', {}) return matrix.get('select_categories', {})
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'))
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 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 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 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 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 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 test_save_pdf_under_form_created_document_annotations(self, browser): self.login(self.regular_user, browser) browser.open(self.document, view='save_pdf_under') browser.forms.get('form').find_field("Destination").fill(self.empty_dossier) with self.observe_children(self.empty_dossier) as children: browser.click_on("Save") self.assertEqual(len(children["added"]), 1) created_document = children["added"].pop() annotations = IAnnotations(created_document) self.assertEqual(IUUID(self.document), annotations.get(PDF_SAVE_SOURCE_UUID_KEY)) self.assertEqual('conversion-demanded', annotations.get(PDF_SAVE_STATUS_KEY)) self.assertIsNotNone(annotations.get(PDF_SAVE_TOKEN_KEY)) self.assertEqual(self.regular_user.getId(), annotations.get(PDF_SAVE_OWNER_ID_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 __get__(self, inst, cls=None): if inst is None: return getObjectSpecification(cls) request = getRequest() annotations = IAnnotations(request) # Return cached spec from request if inst.__parent__ is not None and inst.__name__ is not None: digest = inst.__parent__.schema_digest key = '.'.join([self.__class__.__name__, digest, inst.__name__]) spec = annotations.get(key) if spec is not None: return spec spec = getattr(inst, '__provides__', None) if spec is None: spec = implementedBy(cls) model = load_model( aq_base(inst.__parent__).schema, cache_key=inst.__parent__.schema_digest, ) schemata = [] for schema in [ model.schemata[name] for name in model.schemata if name == u'' or IS_TRANSLATION.match(name) ]: try: field = schema[inst.__name__] except AttributeError: continue try: schemata.append(field.schema) except AttributeError: schemata.append(field.value_type.schema) schemata.append(spec) spec = Implements(*schemata) # Cache spec into request annotations[key] = spec else: spec = getattr(inst, '__provides__', None) if spec is None: spec = implementedBy(cls) # Set by FlowSubmissionDataFactory schemata = [inst._v_initial_schema, spec] spec = Implements(*schemata) return spec
def __get__(self, inst, cls=None): if inst is None: return getObjectSpecification(cls) request = getRequest() annotations = IAnnotations(request) try: digest = inst.schema_digest except AttributeError: spec = getattr(inst, '__provides__', None) if spec is None: return implementedBy(cls) else: return spec # Return cached spec from request if not getattr(self, '__recursion__', False): spec = annotations.get(self.__class__.__name__ + '.' + digest) if spec is not None: return spec spec = getattr(inst, '__provides__', None) if spec is None: spec = implementedBy(cls) model = load_model(inst.schema, cache_key=inst.schema_digest) schemata = [ model.schemata[name] for name in model.schemata if name in [u'', u'++add++'] or IS_TRANSLATION.match(name.split(u'++add++')[0]) ] schemata.append(spec) if getattr(self, '__recursion__', False): return Implements(*schemata) self.__recursion__ = True dynamically_provided = [] try: assignable = IBehaviorAssignable(inst, None) if assignable is not None: for behavior_registration in assignable.enumerateBehaviors(): if behavior_registration.marker: dynamically_provided.append( behavior_registration.marker, ) finally: del self.__recursion__ schemata.extend(dynamically_provided) spec = Implements(*schemata) # Cache spec into request annotations[self.__class__.__name__ + '.' + digest] = spec return spec
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 actionSubmit(self, action, data): annotations = IAnnotations(self.context) if annotations.get(KEY): annotations[KEY] = None msg = _(u"Slideshare id removed") IStatusMessage(self.request).addStatusMessage(msg, type='info') else: msg = _(u"object does not have a slideshare id") IStatusMessage(self.request).addStatusMessage(msg, type='error') self.context.setLayout(self.context.getDefaultLayout()) self.request.response.redirect(self.next_url)
def get_job_annotation(self, job): """ Get job annotation """ portal = getToolByName(self.context, 'portal_url').getPortalObject() portal_anno = IAnnotations(portal) async_job_status = portal_anno.get('async_move_jobs') if async_job_status: job_id = u64(job._p_oid) annotation_job = async_job_status.get(job_id) return annotation_job return None
def is_available(self, data_type='preview'): if data_type == 'pdf': annotations = IAnnotations(self.context) if annotations.get(PDF_VERSION_KEY): return True if self.get_number_of_pages(img_type=data_type) > 0: return True else: if is_autoconv_enabled() and hasattr(self.context, 'REQUEST'): queueConversionJob(self.context, self.context.REQUEST) return False
def addRefreshViewletCommands(event): view = event.view context = view.context request = view.request annotations = IAnnotations(request) viewletByClass = annotations.get('viewletByClass', []) if viewletByClass: for name, manager in getAdapters( (context, request, view, ), IViewletManager): for name, viewlet in getAdapters( (context, request, view, manager), IViewlet): maybeRenderViewlet(viewlet, viewletByClass)
def load(self): annotations = IAnnotations(self.context) default_state = deepcopy(self._default_page_config()) page_state = deepcopy(annotations.get( SL_ANNOTATION_KEY, make_resursive_persistent(default_state))) for slotname in default_state: if not page_state.get(slotname): page_state[slotname] = default_state[slotname] return page_state
def __init__(self, context): self.__parent__ = context self._context = context annotations = IAnnotations(self._context) map = annotations.get(self.key) if map is None: self._byrow = {} self._bycol = {} else: self._byrow = map._byrow self._bycol = map._bycol self.map = map