def __init__(self, context): self.context = context annotations = IAnnotations(context) mapping = annotations.get(KEY) if mapping is None: mapping = annotations[KEY] = PersistentDict({'status' : 'Bad'}) self.mapping = mapping
def challenge( self, request, response, **kw ): """ Challenge the user for credentials. Prevent redirect to login page for paths mentioned in control panel" """ portal = getSite() annotations = IAnnotations(portal) do_basic_auth_paths = annotations.get('rohberg.doorman.do_basic_auth_paths', []) if do_basic_auth_paths: realm = response.realm do_basic_auth = False vup = request.get("VIRTUAL_URL_PARTS", None) if vup: vup = list(vup) if len(vup) > 2: do_basic_auth = vup[2] in do_basic_auth_paths if do_basic_auth: if realm: response.addHeader('WWW-Authenticate', 'basic realm="%s"' % realm) m = "<strong>You are not authorized to access this resource.</strong>" response.setBody(m, is_error=1) response.setStatus(401) return 1 return 0
def get_reference_mapping(self, obj=None): type_key = self.get_type_key(obj) annotations = IAnnotations(self.context) if not annotations.get(type_key): annotations[type_key] = PersistentDict({}) return annotations[type_key]
def storeResponseInRAMCache(request, response, result, globalKey=PAGE_CACHE_KEY, annotationsKey=PAGE_CACHE_ANNOTATION_KEY): """Store the given response in the RAM cache. ``result`` should be the response body as a string. ``globalKey`` is the global cache key. This needs to be the same key as the one used to fetch the data. ``annotationsKey`` is the key in annotations on the request from which the (resource-identifying) caching key should be retrieved. The default is that used by the ``cacheInRAM()`` helper function. """ annotations = IAnnotations(request, None) if annotations is None: return key = annotations.get(annotationsKey) if not key: return cache = getRAMCache(globalKey) if cache is None: return status = response.getStatus() headers = dict(request.response.headers) gzipFlag = response.enableHTTPCompression(query=True) cache[key] = (status, headers, result, gzipFlag)
def get_content_image(context, scale='large', width=None, height=None): request = getRequest() modification = context.ModificationDate() key = "cache-%s-%s-%s-%s-%s" % (context, modification, scale, width, height) cache = IAnnotations(request) img = cache.get(key, None) if not img: view, field = get_images_view(context) if view: try: sizes = view.getImageSize(field) except AttributeError: sizes = img = None if sizes: kwargs = {} if not (width or height): kwargs['scale'] = scale else: new = (width, height) width, height = _image_size(sizes, new) kwargs['width'] = width kwargs['height'] = height kwargs['direction'] = 'down' try: img = view.scale(fieldname=field, **kwargs) except AttributeError: img = None cache[key] = img return img
def _update_AgentInfoPortlet_ProfilePage(self, folders, data): """Override Annotation for plone.mls.listing AgentInfo inside AgentProfilePages""" #get agents portrait/ avatar url avatar_url = self.membershiptool.getPersonalPortrait(id=self.userid).absolute_url() #get AgencyInfo agency = self.__AgencyInfo for folder in folders: if IAgentFolder.providedBy(folder) and ILocalAgencyInfo.providedBy(folder): #get annotations for this folder mls_ano = IAnnotations(folder).get("plone.mls.listing.localagencyinfo", None) if mls_ano is None: #initialize Annotations anno = IAnnotations(folder) anno.get("plone.mls.listing.localagencyinfo", anno.setdefault("plone.mls.listing.localagencyinfo", {})) mls_ano = IAnnotations(folder).get("plone.mls.listing.localagencyinfo", {}) # set global Agency Info mls_ano['agency_name'] = agency.get('agency_name', u'Krain Real Estate') mls_ano['agency_logo_url'] = agency.get('agency_logo_url', u'') mls_ano['agency_office_phone'] = agency.get('agency_office_phone', u'') mls_ano['agency_website'] = agency.get('agency_website', u'') #Agent Info mls_ano['agent_name'] = data.get('fullname', u'') mls_ano['agent_office_phone'] = data.get('office_phone', u'') mls_ano['agent_cell_phone'] = data.get('cell_phone', u'') mls_ano['agent_email'] = data.get('email', u'') mls_ano['agent_avatar_url'] = avatar_url #force overrding of Any other agent mls_ano['force'] = 'selected'
def get_number(self, obj): ann = IAnnotations(obj) if SEQUENCE_NUMBER_ANNOTATION_KEY not in ann.keys(): generator = getAdapter(obj, ISequenceNumberGenerator) value = generator.generate() ann[SEQUENCE_NUMBER_ANNOTATION_KEY] = value return ann.get(SEQUENCE_NUMBER_ANNOTATION_KEY)
def upgrade_executed_jobs_storage(portal_setup): """The executed jobs storage has changed from PersistentList to IOBTree storage, so we need to migrate the storage. """ portal = portal_setup.portal_url.getPortalObject() queue = IQueue(portal) annotations = IAnnotations(portal) if 'publisher-executed' not in annotations: # No data to migrate. return # get jobs directly from the annotations - accessing with # queue methods is not possible yet jobs = list(annotations.get('publisher-executed', [])) # drop the current list del annotations['publisher-executed'] # add every single job with the new methods for job in jobs: queue.append_executed_job(job) # check if it worked assert len(jobs) == queue.get_executed_jobs_length()
def __init__(self, context): self.context = context annotations = IAnnotations(self.context) self.__mapping = annotations.get(self.ANNO_KEY, None) if self.__mapping is None: self.__mapping = PersistentList() annotations[self.ANNO_KEY] = self.__mapping
def openFileReference(transmogrifier, ref): """ Get an open file handle in one of the following forms: * importcontext:file.txt * dotted.package:file.txt * /file/system/file.txt Where "importcontext:" means find the file in the GS import context. Return None if there was no file to be found """ if ref.startswith('importcontext:'): try: from collective.transmogrifier.genericsetup import IMPORT_CONTEXT from zope.annotation.interfaces import IAnnotations context = IAnnotations(transmogrifier).get(IMPORT_CONTEXT, None) (subdir, filename) = os.path.split(ref.replace('importcontext:', '')) if subdir == '': # Subdir of '' results import contexts looking for a '' # directory I think subdir = None if hasattr(context, "openDataFile"): return context.openDataFile(filename, subdir=subdir) if hasattr(context, "readDataFile"): import StringIO return StringIO.StringIO( context.readDataFile(filename, subdir=subdir)) except ImportError: return None # Either no import context or not there. filename = resolvePackageReferenceOrFile(ref) if os.path.isfile(filename): return open(filename, 'r') return None
def show(self): """ Removes all status messages (including HTML) and returns them for display. """ context = self.context annotations = IAnnotations(context) msgs = annotations.get(STATUSMESSAGEKEY, context.cookies.get(STATUSMESSAGEKEY)) msgs = msgs and adapter._decodeCookieValue(msgs) or [] html_msgs = annotations.get(HTMLMESSAGEKEY, context.cookies.get(HTMLMESSAGEKEY)) html_msgs = html_msgs and adapter._decodeCookieValue(html_msgs) or [] for msg in html_msgs: msg.message = literal(sanitize(msg.message, cleaner=msgcleaner, wrap=None)) value = msgs + html_msgs # clear the existing cookie entries, except on responses that don't # actually render in the browser (really, these shouldn't render # anything so we shouldn't get to this message, but some templates # are sloppy). if self.context.response.getStatus() not in (301, 302, 304): context.cookies[STATUSMESSAGEKEY] = None context.response.expireCookie(STATUSMESSAGEKEY, path='/') annotations[STATUSMESSAGEKEY] = None context.cookies[HTMLMESSAGEKEY] = None context.response.expireCookie(HTMLMESSAGEKEY, path='/') annotations[HTMLMESSAGEKEY] = None return value
class TilesPermissions(object): """ An adapter that will provide store permissions for a tile """ implements(ITilesPermissions) def __init__(self, context, request, tile): self.context = context self.request = request self.tile = tile self.annotations = IAnnotations(self.context) self.key = '{0}.{1}'.format(ANNOTATIONS_KEY_PREFIX, tile.id) def get_allowed_edit(self): permissions = dict(self.annotations.get(self.key, {})) return permissions.get('edit', ()) def set_allowed_edit(self, group_ids): permissions = dict(self.annotations.get(self.key, {})) if isinstance(group_ids, list): group_ids = tuple(group_ids) elif isinstance(group_ids, basestring): group_ids = (group_ids,) permissions['edit'] = group_ids self.annotations[self.key] = PersistentDict(permissions) def delete(self): self.annotations.pop(self.key, None) return
def handleUpdate(self, action): data, errors = self.extractData() if errors: self.status = self.formErrorsMessage return annotations = IAnnotations(self.context) storage = annotations.setdefault('geoportlet', PersistentMapping()) database = Software77GeoDatabase(storage) url = data['url'] url = url and url.encode('utf-8') or None try: count = database.update(url) except IOError as exc: IStatusMessage(self.request).addStatusMessage( _(u"An error occurred: ${error}.", mapping={'error': exc}), "info") else: try: count = '{0:,}'.format(count) except ValueError: pass IStatusMessage(self.request).addStatusMessage( _(u"Database updated (${count} records read).", mapping={'count': count}), "info")
def cleanComments(self): """ """ annotations = IAnnotations(self.context) if annotations.has_key(self.key): del annotations[self.key] self._comments = None
def handle_layout(self): """ This will check if the file does not have the document viewer display selected. In addition, if the currently selected display is for wc.pageturner, we'll clean out the annotations from that product. Additionally, we'll also look for wildcard.pdfpal related values. """ current = self.context.getLayout() if current != 'documentviewer': self.context.layout = 'documentviewer' annotations = IAnnotations(self.context) # remove page turner related data = annotations.get('wc.pageturner', None) if data: del annotations['wc.pageturner'] # remove pdfpal related field = self.context.getField('ocrText') if field: field.set(self.context, '') data = annotations.get('wildcard.pdfpal', None) if data: del annotations['wildcard.pdfpal']
def clean_folder(self, catalog, storage_loc): if not os.path.isdir(storage_loc): return 0 count = 0 for foldername in os.listdir(storage_loc): if len(foldername) == 1: # we're in a container, check inside count += self.clean_folder(catalog, os.path.join(storage_loc, foldername)) else: #foldername should be file uid brains = catalog(UID=foldername) folderpath = os.path.join(storage_loc, foldername) if len(brains) == 0: shutil.rmtree(folderpath) count += 1 else: obj = brains[0].getObject() settings = Settings(obj) if obj.getLayout() != 'documentviewer': if not settings.converting: shutil.rmtree(folderpath) count += 1 # also delete settings annotations = IAnnotations(obj) data = annotations.get('collective.documentviewer', None) if data: del annotations['collective.documentviewer'] elif settings.storage_type == 'Blob': shutil.rmtree(folderpath) count += 1 return count
def test_annotations_key_is_cleared(self): annotations = IAnnotations(self.document) self.assertEquals(TEST_USER_ID, annotations.get(CHECKIN_CHECKOUT_ANNOTATIONS_KEY)) self.manager.checkin() self.assertEquals(None, annotations.get(CHECKIN_CHECKOUT_ANNOTATIONS_KEY))
def migrate_portlet_assignments(self, obj): from ftw.subsite.portlets.teaserportlet import ITeaserPortlet try: annotations = IAnnotations(obj) except TypeError: # The obj has no annotations return known_manager = annotations.get( 'plone.portlets.contextassignments', []) for managername in tuple(known_manager): if managername not in self.MANAGER_NAMES: continue manager = getUtility(IPortletManager, name=managername, context=obj) assignments = getMultiAdapter((obj, manager), IPortletAssignmentMapping, context=obj) assignments._p_changed = True for assignment in assignments.values(): if not ITeaserPortlet.providedBy(assignment): continue if not assignment.__dict__.get('image'): continue assignment.image = assignment.__dict__.pop('image', None) assignment._p_changed = True
def localPortletAssignmentMappingAdapter(context, manager): """This is pretty much the same code of the original one from `plone.app.portlets.assignable.localPortletAssignmentMappingAdapter` but it changes the assignment klass with `Mapping`. This is needed in order to use our custom view '+' for adding the portlet. """ annotations = IAnnotations(context) local = annotations.get(CONTEXT_ASSIGNMENT_KEY, None) if local is None: local = annotations[CONTEXT_ASSIGNMENT_KEY] = OOBTree() portlets = local.get(manager.__name__, None) if portlets is None: portlets = local[manager.__name__] = Mapping(manager=manager.__name__, category=CONTEXT_CATEGORY) # XXX: For graceful migration if not getattr(portlets, '__manager__', ''): portlets.__manager__ = manager.__name__ if not getattr(portlets, '__category__', ''): portlets.__category__ = CONTEXT_CATEGORY return portlets
def get_member_vote(self, object): """ """ if not IAttributeAnnotatable.providedBy(object): alsoProvides(object, IAttributeAnnotatable) annotations = IAnnotations(object) voters = annotations.get('opkode.rateablediscussion.voters', {}) return voters.get(self.member.getId(), None)
def getAccessibilityCompliant(self): """ Get the Accessibility Compliant value from the object """ annotations = IAnnotations(self.context) if annotations.has_key('eduCommons.accessible'): return annotations['eduCommons.accessible'] else: return
def __init__(self, context, request): """self:zope.app.pagetemplate.simpleviewclass.SimpleViewClass -> templates/workspace-index.pt context:bungeni.core.content.Section """ LD = IAnnotations(request)["layer_data"] assert interfaces.IWorkspaceSectionLayer.providedBy(request) assert LD.get("workspaces") is not None super(WorkspaceSectionView, self).__init__(context, request) cls_name = self.__class__.__name__ # NOTE: Zope morphs this class's name to "SimpleViewClass from ..." log.debug("%s.__init__ %s context=%s url=%s" % ( cls_name, self, self.context, request.getURL())) # transfer layer data items, for the view/template self.user_id = LD.user_id self.user_group_ids = LD.user_group_ids self.government_id = LD.government_id # may be None self.ministries = LD.ministries # may be None if self.ministries: # then, ONLY if an ancestor container is actually a Ministry, # this must be a MinisterWorkspace if misc.get_parent_with_interface(self, model_interfaces.IMinistry): interface.alsoProvides(self, interfaces.IMinisterWorkspace) # roles are function of the context, so always recalculate roles = get_roles(self.context) for role_id in roles: iface = self.role_interface_mapping.get(role_id) if iface is not None: interface.alsoProvides(self, iface) log.debug("%s.__init__ %s" % (cls_name, debug.interfaces(self)))
def update(self): super(ShopArticleListingViewlet, self).update() annotations = IAnnotations(self.context) current_objs_p_mtime = annotations.get('_objs_p_mtime') objs_p_mtime = [obj.image._p_mtime for obj in self._objs()] if current_objs_p_mtime != objs_p_mtime: annotations['_objs_p_mtime'] = objs_p_mtime
def __init__(self, context, request): super(SQLDexterityPublishTraverse, self).__init__(context, request) annotations = IAnnotations(context) self.fti_id = annotations.get('collective.behavior.sql.sql_type') if self.fti_id: self.fti = getUtility(IDexterityFTI, name=self.fti_id) name = getattr(ISQLTypeSettings(self.fti), 'sql_folder_id', self.fti_id) if name and IRelationValue.providedBy(name): obj = name.to_object if obj: name = obj.getId() else: name = self.fti_id elif name and name.startswith('/'): portal = getToolByName(getSite(), 'portal_url').getPortalObject() obj = portal.restrictedTraverse(name) if obj: name = obj.getId() else: name = self.fti_id elif not name: name = self.fti_id self.name = name self.Title = self.fti.Title()
def selectedPacket(self): annotations = IAnnotations(self.context) packet_key = annotations.get(PACKETS_KEY + '.type') packet_fields = annotations.get(PACKETS_KEY + '.fields') packet_mapui = annotations.get(PACKETS_KEY + '.mapui') return dict(packet_key=packet_key, value=packet_fields.get(packet_mapui.get('codi')), element=packet_fields.get(packet_mapui.get('element')))
def has_videos(self): view = getMultiAdapter((self.context, self.request), name='nota') videos = [] if view: context_path = '/'.join(self.context.getPhysicalPath()) query = {'Type': ('Link',)} query['path'] = {'query': context_path, 'depth': 1, } query['sort_on'] = 'getObjPositionInParent' query['limit'] = None results = self.context.getFolderContents(contentFilter=query, batch=False, b_size=10, full_objects=False) for link in results: link_obj = link.getObject() annotations = IAnnotations(link_obj) is_video = annotations.get('thumbnail_pequeno', None) if is_video: videos.append({'obj': link, 'url': link_obj.absolute_url() + '/@@thumbnail_mediano'}) return videos
def getContent(self): """Get the annotations with the local MLS config.""" annotations = IAnnotations(self.context) return annotations.get( CONFIGURATION_KEY, annotations.setdefault(CONFIGURATION_KEY, {}), )
def get_journal_data(self): if IAnnotationsJournalizable.providedBy(self.context): annotations = IAnnotations(self.context) data = annotations.get(JOURNAL_ENTRIES_ANNOTATIONS_KEY, []) return deepcopy(data) return []
def getSourceName(self, instance): """Get the name of the data source that is used in this context.""" mapping = IAnnotations(instance).setdefault( 'collective.table', PersistentMapping() ) return mapping.get('source_name', self.defaultSourceName)
def purge_unassigned_notes(context): # this indiscriminately purge all notes not found within an file's # specified exposure file type. # XXX implement an alternate option that will retain any specified # notes # XXX don't make this method available in the upgrade step just yet. from zope.annotation.interfaces import IAnnotations prefix = 'pmr2.annotation.notes-' catalog = getToolByName(context, 'portal_catalog') files = catalog(portal_type='ExposureFile') for b in files: file = b.getObject() ftpath = file.file_type if not ftpath: continue cftviews = filetypes[ftpath] # file type views for current file # remove unreferenced annotations # XXX this assumes users don't manually assign views after # specifying file types. annotations = IAnnotations(file) for k in annotations.keys(): if not k.startswith(prefix): continue viewname = k[len(prefix):] if not viewname in cftviews: del annotations[k]
def get_total(context, paragrafo_id): """ Devolve um dicionário com total de concordâncias e discordâncias. """ inicializa_anotacoes(context) annotations = IAnnotations(context) ressalvas = 0 for voto in annotations[concordancias][paragrafo_id].itervalues(): if 'ressalva' in voto.keys(): ressalvas += 1 return { 'concordancias': (len(annotations[concordancias][paragrafo_id]) - ressalvas), 'concordancias_ressalva': ressalvas, 'discordancias': len(annotations[discordancias][paragrafo_id]) }
def avoid_profile_reinstallation(event): profile = re.sub('^profile-', '', event.profile_id) assert profile not in FORBIDDEN_PROFILES, \ 'It is not allowed to install the profile {!r}.'.format(profile) request = getSite().REQUEST annotations = IAnnotations(request) key = 'opengever.core:avoid_profile_reinstallation' if key not in annotations: annotations[key] = [] if should_prevent_duplicate_installation(profile): assert profile not in annotations[key], \ 'Profile {!r} should not be installed twice.'.format(profile) elif profile in annotations[key]: LOG.warning('%r installed twice', profile) annotations[key].append(profile)
def test_inactive_links_if_document_is_checked_out(self, browser): """Check the document overview when the document is checked out, by another user: - checked out information - edit link is inactive """ IAnnotations( self.document)[CHECKIN_CHECKOUT_ANNOTATIONS_KEY] = 'hugo.boss' transaction.commit() browser.login().visit(self.document, view='tabbedview_view-overview') self.assertEquals('Checkout and edit', browser.css('.function-edit-inactive').first.text) self.assertEquals( 'Download copy', browser.css('.function-download-copy-inactive').first.text)
def action_save(self, action, data): request = self.context.request context = Acquisition.aq_inner(self.context) canonical = context.getCanonical() annotations = IAnnotations(canonical) annotations[FEED_KEY] = data[FEED_KEY] if data[PRESS_CONTACTS_KEY]: annotations[PRESS_CONTACTS_KEY] = \ request.form.get('form.press_contacts', []) if data[KEYWORDS_KEY]: annotations[KEYWORDS_KEY] = \ (data[KEYWORDS_KEY]).strip().split(' ') else: annotations[KEYWORDS_KEY] = [] return request.RESPONSE.redirect('%s/@@dynamic-pressroom/' % '/'.join(context.getPhysicalPath()))
def test_standard_fs_workflow(self): # Register a backend that requires filesystem self.portal.getSiteManager().registerUtility(self.backend, provided=IStorageBackend, name=u'dummy_fs_backend') utilities = getUtility(IUtilityRegistry, 'repodono.storage.backends') utilities.enable('dummy_fs_backend') installer = getUtility(IStorageInstaller) installer(self.folder, 'dummy_fs_backend') self.assertIn('repodono.storage.base.StorageInfo', IAnnotations(self.folder).keys()) storage = IStorage(self.folder) self.assertEqual(storage.path, join(self.tempdir, 'plone', TEST_FOLDER_ID)) self.assertTrue(exists(storage.path))
def set_json(self, value): """ Set json dict Items are not persisted within annotations, they should be dynamically generated each time according with JSON['properties'] >>> visualization.json = { ... 'items': [1, 2, 3], ... 'properties': {'a': 'b'}} >>> visualization.json {'items': [], 'properties': {'a': 'b'}} """ value['items'] = [] value.setdefault('properties', {}) anno = IAnnotations(self.context) anno[ANNO_JSON] = PersistentDict(value)
def test_annotation_source_schema_violation_recovery(self): dummy = IDummy3(self.portal) dummy.field2 = u'A valid value' annotations = IAnnotations(self.portal) value = annotations['repodono.storage.tests.test_annotation.Dummy3'] value['field2'] = 222 self.assertRaises(TypeError, IDummy3, self.portal) # can still extract with a bare alternative class that isn't # registered in ZCA but references the correct call @annotator(IDummy3, to_key(__name__, 'Dummy3')) class Dummy3alt(object): pass dummy = Dummy3alt(self.portal) self.assertEqual(dummy.field2, 222)
def test_no_purger(self): request = FauxRequest() alsoProvides(request, IAttributeAnnotatable) IAnnotations(request)['plone.cachepurging.urls'] = set(['/foo', '/bar']) registry = Registry() registry.registerInterface(ICachePurgingSettings) provideUtility(registry, IRegistry) settings = registry.forInterface(ICachePurgingSettings) settings.enabled = True settings.cachingProxies = ('http://localhost:1234',) try: notify(PubSuccess(request)) except: self.fail()
def upgrade_181_190_1(context, logger=None): if logger is None: logger = LOG # Run GS steps setup = getToolByName(context, 'portal_setup') setup.runImportStepFromProfile(PROFILE_ID, 'controlpanel') setup.runImportStepFromProfile(PROFILE_ID, 'catalog') setup.runImportStepFromProfile(PROFILE_ID, 'actions') setup.runImportStepFromProfile(PROFILE_ID, 'plone.app.registry') # finally remove the internal rdf graph which may still linger around pannots = IAnnotations(api.portal.get()) if 'gu.plone.rdf' in pannots: del pannots['gu.plone.rdf'] # rebuild the catalog to make sure new indices are populated logger.info("rebuilding catalog") pc = getToolByName(context, 'portal_catalog') pc.clearFindAndRebuild() logger.info("finished")
def send_report(portal, lines): """Send email if required.""" emails = api.portal.get_registry_record( 'collective.contact.importexport.interfaces.IPipelineConfiguration.emails' ) if not emails: return msg = create_html_email(u'\n'.join( [u'<p>{}</p>'.format(line) for line in lines])) annot = IAnnotations(portal).get(ANNOTATION_KEY) for filename in ('ie_input_errors.log', 'ie_shortlog.log'): path = os.path.join(annot['wp'], filename) add_attachment(msg, filename, filepath=path) mfrom = portal.getProperty('email_from_address') ret, error = send_email(msg, u'Contact import report', mfrom, emails) if not ret: with open(os.path.join(annot['wp'], 'ie_input_errors.log'), 'a') as f: f.write('Your email has not been sent: {}'.format(error))
class FeedSettings: adapts(ISyndicatable) def __init__(self, context): self.context = context self.annotations = IAnnotations(context) self.needs_saving = False self._metadata = self.annotations.get(FEED_SETTINGS_KEY, None) if self._metadata is None: self._metadata = PersistentDict() self.needs_saving = True registry = getUtility(IRegistry) self.site_settings = registry.forInterface(ISiteSyndicationSettings, check=False) def _set(self): """ what are we doing here you might ask? well, this causes us to write on read so only set on annotation if we need to """ if self.needs_saving: self.annotations[FEED_SETTINGS_KEY] = self._metadata def __setattr__(self, name, value): if name in ('context', '_metadata', 'site_settings', 'annotations', 'needs_saving'): self.__dict__[name] = value else: self._metadata[name] = value self._set() def __getattr__(self, name): default = None if name in ISiteSyndicationSettings.names(): default = getattr(self.site_settings, name) elif name == 'enabled' and self.site_settings.default_enabled: default = True elif name in IFeedSettings.names(): default = IFeedSettings[name].default return self._metadata.get(name, default)
def get_event_list(self, start=None, stop=None): now = DateTime() events = (i.getObject() for i in self.get_events() if not (getattr(i, 'outdated', False) and isExpired(i))) months = [] month_info = [] old_month_year = None for event in events: start = event.start() month = str(start.month()) year = str(start.year()) month_year = year + month if month_year != old_month_year: old_month_year = month_year if month_info: months.append(month_info) month_info = { 'month': start.month(), 'year': start.year(), # e.g. month_oct as used in the plonelocales i18n:domain 'month_name': "month_%s" % (start.strftime("%B").lower()[:3]), 'events': [] } isDateToBeConfirmed = (True if hasattr(event, "dateToBeConfirmed") and event.dateToBeConfirmed else False) isOutdated = IAnnotations(event).get("slc.outdated", False) event_dict = { 'event': event, 'day': start.day(), 'start': start, 'end': event.end(), 'location': event.getLocation(), 'title': event.Title(), 'description': event.Description(), 'url': event.absolute_url(), 'is_tbc': isDateToBeConfirmed, 'is_outdated': isOutdated } month_info['events'].append(event_dict) if month_info: months.append(month_info) return months
def annotation_alias(annotation_name, annotation_property=None, default=None, delete=False, delete_quiet=True, doc=None): """ Returns a property that is a read/write alias for a value stored as a :class:`zope.annotation.interface.IAnnotations`. The object itself may be adaptable to an IAnnotations, or a property of the object may be what is adaptable to the annotation. The later is intended for use in adapters when the context object is what should be adapted. :keyword bool delete: If ``True`` (not the default), then the property can be used to delete the annotation. :keyword bool delete_quiet: If ``True`` and `delete` is also True, then the property will ignore key errors when deleting the annotation value. :keyword str annotation_property: If set to a string, it is this property of the object that will be adapted to IAnnotations. Most often this will be ``context`` when used inside an adapter. """ if doc is None: doc = 'Alias for annotation ' + annotation_name factory = IAnnotations if annotation_property: factory = lambda self: IAnnotations(getattr(self, annotation_property)) fget = lambda self: factory(self).get(annotation_name, default) fset = lambda self, nv: operator.setitem(factory(self), annotation_name, nv ) fdel = None if delete: def fdel(self): try: del factory(self)[annotation_name] except KeyError: if not delete_quiet: raise return property(fget, fset, fdel, doc=doc)
class PersistentTileDataManager(object): """A data reader for persistent tiles operating on annotatable contexts. The data is retrieved from an annotation. """ def __init__(self, tile): self.tile = tile self.tileType = queryUtility(ITileType, name=tile.__name__) self.context = getMultiAdapter( (tile.context, tile.request, tile), ITileDataContext) self.annotations = IAnnotations(self.context) self.key = '.'.join([ANNOTATIONS_KEY_PREFIX, str(tile.id)]) def _get_default_request_data(self): # If we don't have a schema, just take the request if self.tileType is None or self.tileType.schema is None: data = self.tile.request.form.copy() else: # Try to decode the form data properly if we can try: data = decode(self.tile.request.form, self.tileType.schema, missing=True) except (ValueError, UnicodeDecodeError,): LOGGER.exception(u'Could not convert form data to schema') return self.data.copy() return data def get(self): data = self._get_default_request_data() data.update(dict(self.annotations.get(self.key, {}))) if self.tileType is not None and self.tileType.schema is not None: for name, field in getFields(self.tileType.schema).items(): if name not in data: data[name] = field.missing_value return data def set(self, data): self.annotations[self.key] = PersistentDict(data) def delete(self): if self.key in self.annotations: del self.annotations[self.key]
def add_rule(self, data, trigger_type): ''' Create new rule require data related to field values to create new rule ''' rule_name = _( u'IFTTT ${trigger_type} for "${ifttt_event_name}" on ' u'content_types ${content_types} at ${path}', mapping=dict( trigger_type=trigger_type, ifttt_event_name=data.get('ifttt_event_name'), content_types=(', ').join(data.get('content_types')), title=self.context.Title(), path=self.context.absolute_url_path(), )) rule_description = _( u'This rule triggers an IFTTT event ' u'"${ifttt_event_name}" on the ${title} folder', mapping=dict( ifttt_event_name=data.get('ifttt_event_name'), title=safe_unicode(self.context.Title()), )) portal = api.portal.get() adding = getMultiAdapter((portal, self.request), name='+rule') addview = getMultiAdapter((adding, self.request), name='plone.ContentRule') addview.form_instance.update() content = addview.form_instance.create({ 'title': rule_name, 'description': rule_description, 'enabled': True, 'stop': False, 'cascading': False, 'event': data.get('event') }) addview.form_instance.add(content) # clear status messages from pipeline annotations = IAnnotations(self.request) annotations[STATUSMESSAGEKEY] = None
def test_migrate_comment(self): # Create a comment talkback = self.discussion.getDiscussionFor(self.doc) self.doc.talkback.createReply('My Title', 'My Text', Creator='Jim') reply = talkback.getReplies()[0] reply.setReplyTo(self.doc) reply.creation_date = DateTime(2003, 3, 11, 9, 28, 6, 'GMT') reply.modification_date = DateTime(2009, 7, 12, 19, 38, 7, 'GMT') self._publish(reply) self.assertEqual(reply.Title(), 'My Title') self.assertEqual(reply.EditableBody(), 'My Text') self.assertTrue('Jim' in reply.listCreators()) self.assertEqual(talkback.replyCount(self.doc), 1) self.assertEqual(reply.inReplyTo(), self.doc) # Call migration script self.view() # Make sure a conversation has been created self.assertTrue( 'plone.app.discussion:conversation' in IAnnotations(self.doc)) conversation = IConversation(self.doc) # Check migration self.assertEqual(conversation.total_comments, 1) self.assertTrue(conversation.getComments().next()) comment1 = conversation.values()[0] self.assertTrue(IComment.providedBy(comment1)) self.assertEqual(comment1.Title(), 'My Title') self.assertEqual(comment1.text, '<p>My Text</p>\n') self.assertEqual(comment1.mime_type, 'text/html') self.assertEqual(comment1.Creator(), 'Jim') self.assertEqual(comment1.creation_date, datetime(2003, 3, 11, 9, 28, 6)) self.assertEqual(comment1.modification_date, datetime(2009, 7, 12, 19, 38, 7)) self.assertEqual([{ 'comment': comment1, 'depth': 0, 'id': long(comment1.id) }], list(conversation.getThreads())) self.assertFalse(self.doc.talkback)
def delete_portlet(self, obj, portlet): """ Delete the defined portlet on obj """ ann = IAnnotations(obj) columnkey = 'plone.leftcolumn' if not 'plone.portlets.contextassignments' in ann: logger.error("No portlets defined in this context") elif not columnkey in ann['plone.portlets.contextassignments']: logger.error("Column '%s' not found in portlets definition" % columnkey) elif not portlet in ann['plone.portlets.contextassignments'][columnkey]: logger.error( "Portlet '%s' in '%s' not found in portlets definition" % (portlet, columnkey)) else: fixing_up = contained.fixing_up contained.fixing_up = True del ann['plone.portlets.contextassignments'][columnkey][portlet] # revert our fixing_up customization contained.fixing_up = fixing_up
def __init__(self, transmogrifier, name, options, previous): self.previous = previous self.portal = transmogrifier.context self.storage = IAnnotations(transmogrifier).get(ANNOTATION_KEY) self.ids = self.storage['ids'] creating_group = safe_unicode(options.get('creating_group', '').strip()) if not creating_group: raise Exception(u'{}: You have to set creating_group value in this section !'.format(name)) reg = api.portal.get_registry_record('imio.dms.mail.browser.settings.IImioDmsMailConfig.contact_group_encoder') if not reg: raise Exception(u'{}: You have to activate the contact creating group option in iadocs config'.format(name)) # get imio.dms.mail.ActiveCreatingGroupVocabulary from imio.dms.mail.vocabularies import ActiveCreatingGroupVocabulary voc = ActiveCreatingGroupVocabulary()(self.portal) creating_groups = {term.title: term.value for term in voc} if creating_group not in creating_groups: raise Exception(u"{}: given creating_group '{}' isn't an active creating group organization".format( name, creating_group)) self.creating_org = creating_groups[creating_group]
def test_remove_orphan_annotations(self): from collective.cover.tiles.configuration import ANNOTATIONS_KEY_PREFIX from zope.annotation.interfaces import IAnnotations title = u'Remove orphan annotations' step = self._get_upgrade_step(title) self.assertIsNotNone(step) # simulate state on previous version c1 = self._create_cover('c1', 'Layout A') annotations = IAnnotations(c1) foo = ANNOTATIONS_KEY_PREFIX + '.foo' annotations[foo] = 'bar' # add orphan annotation self._create_cover('c2', 'Layout B') # cover with no annotations # simulate state on previous version self._do_upgrade_step(step) self.assertNotIn(foo, annotations)
def __convert_document(obj, named_file, target_extension, fusion_data): # section of convert_document process that should be run asyncronously converted_file = get_converted_file( named_file, target_extension, fusion_data, ) annotations = IAnnotations(obj) previous_status = annotations[STATUS_STORAGE_KEY] if converted_file is None: new_status = TASK_FAILED annotations[DATA_STORAGE_KEY] = None else: new_status = TASK_SUCCEEDED annotations[DATA_STORAGE_KEY] = converted_file annotations[STATUS_STORAGE_KEY] = new_status if new_status != previous_status: obj.setModificationDate(DateTime())
def _init_search_term(self): if self.query_term not in self.request.form: return annotations = IAnnotations(self.request) if 'trysuggestion' not in annotations: annotations['trysuggestion'] = True suggestion = self.suggest(term=self.request.form[self.query_term], encode='utf-8') if suggestion and suggestion != self.request.form[self.query_term]: logger.info( "query:%s suggestion:%s term:%s", self.request.form[self.query_term], suggestion, self.query_term, ) self.request.form[self.query_term + "Original"] = self.request.form[ self.query_term] self.request.form[self.query_term] = suggestion
def __call__(self, REQUEST, RESPONSE): annotations = IAnnotations(self.context) minuta_exportada_csv = u'Planilha de dados da minuta de participação\n' texto = self.context.text if not texto: return '' pq_texto = pq(texto.output) for i, paragrafo in enumerate(pq_texto.find('.paragrafo')): paragrafo_id = i + 1 minuta_exportada_csv += u'Parágrafo %d; %s;\n' % (paragrafo_id, paragrafo.text) # Criação das linhas de dados de usuário que concordaram concordancias_paragrafo = annotations[concordancias][paragrafo_id] linha_minuta_concordantes = u'Usuários Concordantes: ;' linha_minuta_ressalvas = u'Ressalvas: ;' for usuario_concordante in concordancias_paragrafo: voto = concordancias_paragrafo[usuario_concordante] if voto.get('has_voted', False): linha_minuta_concordantes += usuario_concordante + u';' linha_minuta_ressalvas += safe_unicode(voto['ressalva'].replace('\n', ' ')) + u';' \ if 'ressalva' in voto else u' ;' minuta_exportada_csv += linha_minuta_concordantes + u'\n' minuta_exportada_csv += linha_minuta_ressalvas + u'\n' # Criação das linhas de dados de usuário que discordam discordancias_paragrafo = annotations[discordancias][paragrafo_id] linha_minuta_discordantes = u'Usuários Discordantes: ;' for usuario_discordante in discordancias_paragrafo: voto = discordancias_paragrafo[usuario_discordante] if voto.get('has_voted', False): linha_minuta_discordantes += usuario_discordante + u';' minuta_exportada_csv += linha_minuta_discordantes + u'\n' RESPONSE.setHeader('Content-Type', 'text/csv; charset=ISO-8859-1') RESPONSE.setHeader('Content-Length', len(minuta_exportada_csv)) RESPONSE.setHeader('Content-Disposition', 'attachment; filename="Relatorio.csv"') return minuta_exportada_csv
def _getBlacklist(self, create=False): if IAnnotations.providedBy(self.context): annotations = self.context else: annotations = queryAdapter(self.context, IAnnotations) local = annotations.get(CONTEXT_BLACKLIST_STATUS_KEY, None) if local is None: if create: local = annotations[ CONTEXT_BLACKLIST_STATUS_KEY] = PersistentDict() else: return None blacklist = local.get(self.manager.__name__, None) if blacklist is None: if create: blacklist = local[self.manager.__name__] = PersistentDict() else: return None return blacklist
def __iter__(self): start_time = time() count = 0 problematic = 0 for item in self.previous: # source sections add store path of current generated item in annotation # it gives posibility to monitor what items go through all pipeline # sections between source section and this section and what don't if self.pathkey in item and item[self.pathkey] in self.storage: self.storage.remove(item[self.pathkey]) count += 1 # print item data stored on keys given as option items = [] for key in item.keys(): if self.keys(key)[0] is not None: items.append("%s=%s" % (key, item[key])) if items: msg = ", ".join(items) logging.getLogger(self.logger).info(msg) yield item working_time = int(round(time() - start_time)) # log items that maybe have some problems if self.storage: problematic = len(self.storage) logging.getLogger(self.logger).warning('\nNext objects didn\'t go through full pipeline:\n%s' % \ '\n'.join(['\t'+i for i in self.storage])) # delete validation data from annotations anno = IAnnotations(self.transmogrifier) if VALIDATIONKEY in anno: del anno[VALIDATIONKEY] seconds = working_time % 60 minutes = working_time / 60 % 60 hours = working_time / 3600 stats = "\nPipeline processing time: %02d:%02d:%02d\n" % ( hours, minutes, seconds) stats += "\t%4d items were generated in source sections\n" % ( count + problematic) stats += "\t%4d went through full pipeline\n" % count stats += "\t%4d were discarded in some section" % problematic logging.getLogger(self.logger).info(stats)
def test_consumePermanentToken(self): """When oneTime is False for at leat one action""" token = self.utility.enablePowerToken(self.doc, 'foo', oneTime=False) configuration = IAnnotations(self.doc)[config.MAIN_TOKEN_NAME] self.assertEquals(len(configuration), 1) self.assertEquals(len(configuration[token]), 1) self.utility.consumeToken(self.doc, token) self.utility.consumeToken(self.doc, token) self.assertEquals(len(configuration), 1) # now add another non-permanent action self.utility.addAction(self.doc, token, 'anotherFoo') self.assertEquals(len(configuration), 1) self.assertEquals(len(configuration[token]), 2) self.utility.consumeToken(self.doc, token) self.assertEquals(len(configuration), 1) self.assertEquals(len(configuration[token]), 1) self.utility.consumeToken(self.doc, token) self.assertEquals(len(configuration), 1) self.assertEquals(len(configuration[token]), 1)
def test_enabled_no_paths(self): context = FauxContext() request = FauxRequest() alsoProvides(request, IAttributeAnnotatable) setRequest(request) registry = Registry() registry.registerInterface(ICachePurgingSettings) provideUtility(registry, IRegistry) settings = registry.forInterface(ICachePurgingSettings) settings.enabled = True settings.cachingProxies = ('http://localhost:1234',) notify(Purge(context)) self.assertEqual({'plone.cachepurging.urls': set()}, dict(IAnnotations(request)))
def _exportNode(self): """ Export the contents as an xml node """ node = MembraneToolXMLAdapter._exportNode(self) mbtool = getToolByName(self.context, 'membrane_tool') annot = IAnnotations(mbtool) try: htype = annot[ANNOT_KEY]['hash_type'] child = self._doc.createElement('hash-type') child.setAttribute('name', htype) fragment = self._doc.createDocumentFragment() fragment.appendChild(child) node.appendChild(fragment) self._logger.info("Remember hash-type exported: %s" % htype) except KeyError: # no hash_type annotated on mbtool, no need to add node pass return node
def __call__(self): """info is a dict of uid:[list of chart ids] values """ form = self.request.form uid = form.get("daviz_uid", "").strip() obj = self.context annot = IAnnotations(obj) if not KEY in annot: annot[KEY] = PersistentMapping() info = annot[KEY].get(uid) if not info: info = annot[KEY][uid] = OrderedDict() previous_info = dict(info) info.clear() #this is a string like: 'chart_1=preview&chart_2=live' #from urlparse import parse_qs #cannot use parse_qs because it doesn't guarantee order req_charts = form.get("charts", "").strip() charts = [] for pair in req_charts.split("&"): if pair: chart_id, embed = pair.split("=") chart_settings = PersistentMapping() chart_settings['type'] = embed for prev_key, prev_val in previous_info.get(chart_id, {}).\ items(): if prev_key != 'type': chart_settings[prev_key] = prev_val charts.append((chart_id, chart_settings)) info.update(charts) self.context._p_changed = True return "OK"
def __iter__(self): for item in self.previous: properties = item['_properties'] for prop in properties: if not prop[0] == 'default_page': yield item continue obj = self.context.unrestrictedTraverse( str(item['_path']).lstrip('/'), None) # Hack to know in an other migration if the object is # a default view object. IAnnotations(obj)[MIGR_KEY] = '%s/%s' % (item['_path'], prop[1]) yield item
def indexObject(obj, path): if (base_hasattr(obj, 'reindexObject') and safe_callable(obj.reindexObject)): try: self.reindexObject(obj, idxs=idxs) # index conversions from plone.app.discussion annotions = IAnnotations(obj) if DISCUSSION_ANNOTATION_KEY in annotions: conversation = annotions[DISCUSSION_ANNOTATION_KEY] conversation = conversation.__of__(obj) for comment in conversation.getComments(): try: self.indexObject(comment, idxs=idxs) except StopIteration: # pragma: no cover pass except TypeError: # Catalogs have 'indexObject' as well, but they # take different args, and will fail pass