def getContext(context=None):
if context is NO_VALUE or context is None or not IFolderish.providedBy(context):
#return SimpleVocabulary(terms)
req = getRequest()
for parent in req.PARENTS:
if IFolderish.providedBy(parent):
context = parent
break
return context
def get_media_container(self):
container = None
config_media_path = api.portal.get_registry_record(
'collective.behavior.relatedmedia.media_container_path')
nav_root = api.portal.get_navigation_root(self.context)
media_path = "{}{}".format(
'/'.join(nav_root.getPhysicalPath()), config_media_path)
try:
container = self.context.restrictedTraverse(safe_utf8(media_path))
except:
# try to create media folder
container = nav_root
for f_id in config_media_path.split('/'):
if not f_id:
continue
if not hasattr(container, f_id):
container = createContentInContainer(
container, 'Folder', id=f_id, title=f_id,
exclude_from_nav=True, checkConstraints=False)
else:
container = container[f_id]
if container is None:
container = aq_inner(self.context)
while not IFolderish.providedBy(container):
container = aq_parent(container)
return container
def list_content(content, callback):
"""Recursively list CMF content out of the given one. ``callback``
is called every thousand items after a commit.
"""
def recurse(content):
for child in content.contentValues():
if IFolderish.providedBy(child):
for grandchild in recurse(child):
yield grandchild
yield child
count = 0
total = 0
if IFolderish.providedBy(content):
for child in recurse(content):
yield child
count += 1
total += 1
if count > 200:
logger.info('{0} items indexed'.format(total))
transaction.commit()
content._p_jar.cacheGC()
callback()
count = 0
yield content
elif IContentish.providedBy(content):
yield content
def can_configure(self):
"""Check if folderview can be configured on context"""
context = self.context
if not IFolderish.providedBy(context):
return False
already_activated = self.isFolderViewActivated()
return (not already_activated)
def update(self):
super(LogoViewlet, self).update()
context = aq_inner(self.context)
p_properties = getToolByName(context, 'portal_properties')
if hasattr(p_properties, 'folder_logo_properties'):
portal = self.portal_state.portal()
bprops = portal.restrictedTraverse('base_properties', None)
title = None
folder_logo_properties = getattr(p_properties, 'folder_logo_properties')
logo_id = IFolderLogoProperties(folder_logo_properties).logo_id
context = aq_inner(self.context)
catalog = getToolByName(context, 'portal_catalog')
folders = [folder for folder in aq_chain(context) if IFolderish.providedBy(folder)]
logos = []
for folder in folders:
path = '/'.join(folder.getPhysicalPath())
brains = catalog(
path=dict(query=path, depth=1),
id = logo_id,
object_provides = IATImage.__identifier__,
)
if len(brains) != 0:
logos.append(brains[0])
if len(logos) != 0:
logoName = logo_id
title = logos[0].Title
portal = aq_parent(logos[0].getObject())
elif bprops is not None:
logoName = bprops.logoName
else:
logoName = 'logo.jpg'
self.logo_tag = portal.restrictedTraverse(logoName).tag()
self.portal_title = title or self.portal_state.portal_title()
def background(self):
context = aq_inner(self.context)
p_properties = getToolByName(context, 'portal_properties')
if hasattr(p_properties, 'folder_logo_properties'):
catalog = getToolByName(context, 'portal_catalog')
folder_logo_properties = getattr(p_properties, 'folder_logo_properties')
flp = IFolderLogoProperties(folder_logo_properties)
color = flp.background_color
image_id = flp.background_image_id
folders = [folder for folder in aq_chain(context) if IFolderish.providedBy(folder)]
images = []
for folder in folders:
path = '/'.join(folder.getPhysicalPath())
brains = catalog(
path=dict(query=path, depth=1),
id = image_id,
object_provides = IATImage.__identifier__,
)
if len(brains) != 0:
images.append(brains[0])
if len(images) != 0:
image_path = images[0].getPath()
style = "background: %s url(%s) no-repeat;" % (color, image_path)
else:
style = "background: %s no-repeat;" % (color)
return style
def getBreadcrumbs(self, path=None):
""" Get breadcrumbs """
result = []
root_url = getNavigationRoot(self.obj)
root = aq_inner(self.obj.restrictedTraverse(root_url))
root_url = root.absolute_url()
if path is not None:
root_abs_url = root.absolute_url()
path = path.replace(root_abs_url, '', 1)
path = path.strip('/')
root = aq_inner(root.restrictedTraverse(path))
relative = aq_inner(self.obj).getPhysicalPath()[len(root.getPhysicalPath()):]
if path is None:
# Add siteroot
result.append({'title': root.title_or_id(),
'url': '/'.join(root.getPhysicalPath())})
for i in range(len(relative)):
now = relative[:i + 1]
obj = aq_inner(root.restrictedTraverse(now))
if IFolderish.providedBy(obj):
if not now[-1] == 'talkback':
result.append({'title': obj.title_or_id(),
'url': root_url + '/' + '/'.join(now)})
return result
def getLanguage(self, langs, env):
if not IFtwSubsiteLayer.providedBy(env):
return base_negotiator.getLanguage(langs, env)
# Get current published object
obj = find_context(env)
# Filter out CSS/JS and other non contentish objects
# IFolderish check includes site root
if not (IContentish.providedBy(obj) or IFolderish.providedBy(obj)):
return base_negotiator.getLanguage(langs, env)
nav_root = get_nav_root(obj)
if ISubsite.providedBy(nav_root):
# Get language stored on Subsite
language = nav_root.force_language
if language:
return language
else:
return base_negotiator.getLanguage(langs, env)
else:
# Use normal Negotiator
return base_negotiator.getLanguage(langs, env)
def update(self):
super(LogoViewlet, self).update()
context = aq_inner(self.context)
registry = getUtility(IRegistry)
portal = self.portal_state.portal()
bprops = portal.restrictedTraverse('base_properties', None)
title = None
logo_id = registry.get('collective.folderlogo.logo_id', u'logo')
context = aq_inner(self.context)
catalog = getToolByName(context, 'portal_catalog')
folders = [folder for folder in aq_chain(context) if IFolderish.providedBy(folder)]
logos = []
for folder in folders:
path = '/'.join(folder.getPhysicalPath())
brains = catalog(
path=dict(query=path, depth=1),
id=logo_id,
object_provides=IATImage.__identifier__)
if len(brains) != 0:
logos.append(brains[0])
if len(logos) != 0:
logoName = logo_id
title = logos[0].Title
portal = aq_parent(logos[0].getObject())
elif bprops is not None:
logoName = bprops.logoName
else:
logoName = 'logo.jpg'
self.logo_tag = portal.restrictedTraverse(str(logoName)).tag()
self.portal_title = title or self.portal_state.portal_title()
def set_folder_context_path(path, context):
"""
Retorna o contexto da pas
Args:
path (list): Do caminho onde a pasta será criada
context (plone context): Contexto de onde irá criar a pasta
Returns:
Retorna o contexto da ultima pasta criada
"""
if path:
#Remove espacos em branco da lista
path = [i for i in path if i]
if path:
p = path[0]
normalizer = component.getUtility(IIDNormalizer)
id = normalizer.normalize(p)
if context.get(id, False):
folder = context[id]
if IFolderish.providedBy(folder):
if len(path) <= 1:
return folder
else:
return False
else:
return False
return set_folder_context_path(path[1:], folder)
else:
return context
def displayMailTab(self):
# Cannot mail into the portal root
if self.context.restrictedTraverse(
'@@plone_context_state').is_portal_root():
return False
return IFolderish.providedBy(self.context) and \
_checkPermission(AddPortalContent, self.context)
def get_editor_language(request):
""" Get editor language override
"""
cached = getattr(request, "_cached_admin_language", None)
if cached:
return cached
alwaysTranslate = getattr(request, "alwaysTranslate", None)
if alwaysTranslate:
return None
context = find_context(request)
# Filter out CSS and other non-sense
# IFolderish check includes site root
if not (IContentish.providedBy(context) or IFolderish.providedBy(context)):
# Early terminate
return None
# Check if we are the editor
portal_state = getMultiAdapter((context, request),
name="plone_portal_state")
if portal_state.anonymous():
# Anon visitor, normal language ->
request.alwaysTranslate = True
return None
language = 'en'
# english for all authenticated users
request._cached_admin_language = language
return language
def export(self, folder, recursive=False):
"""
Export content items.
Possible to do recursively nesting into the children.
:return: list of dictionaries
"""
from plone.dexterity.content import Container
from plone.dexterity.content import Item
array = []
for obj in folder.listFolderContents():
# import pdb; pdb.set_trace()
if isinstance(obj,Container) or isinstance(obj, Item):
data = self.grabDexterityData(obj)
else:
data = self.grabArchetypesData(obj)
data.update(self.grabAttributes(obj))
if recursive:
if IFolderish.providedBy(obj):
data["children"] = self.export(obj, True)
array.append(data)
return array
def _walk(self, obj, level=-1):
yield self._getInfo(obj)
if level != 0 and (IFolderish.providedBy(obj) \
or IBaseFolder.providedBy(obj)):
for v in obj.contentValues():
for i in self._walk(v, level - 1):
yield i
def recurse(tree, report_file):
""" Walk through all the content on a Plone site """
print 'Checking %s' % tree.getId()
for id, child in tree.contentItems():
report_objects_with_broken_blobs(child, report_file)
if IFolderish.providedBy(child):
recurse(child, report_file)
def __call__(self):
"""Return the rendered contents of the viewlet manager specified."""
manager = self.data.get('manager')
viewName = self.data.get('view', None)
section = self.data.get('section', 'body')
viewlet = self.data.get('viewlet', None)
view = findView(self, viewName)
if not IFolderish.providedBy(self.context):
self.context = self.context.aq_parent
managerObj = queryMultiAdapter(
(self.context, self.request, view),
IViewletManager,
name=manager
)
managerObj.update()
obj_to_render = managerObj
if viewlet:
provided_viewlets = [i.__name__ for i in managerObj.viewlets]
if viewlet not in provided_viewlets:
mgr_name = managerObj.__name__
msg = 'Viewlet %s is not provided by %s' % (viewlet,
mgr_name)
raise ValueError(msg)
obj_to_render = [i for i in managerObj.viewlets
if i.__name__ == viewlet][0]
if section == 'head':
return u"<html><head>%s</head></html>" % obj_to_render.render()
else:
return u"<html><body>%s</body></html>" % obj_to_render.render()
def getBreadcrumbs(self, path=None):
"""Patch for displaying plone root in tiny mce breadcrumbs for
browsing language neutral folders located next to language folders.
"""
result = []
root = getUtility(ISiteRoot)
root_url = root.absolute_url()
if path is not None:
root_abs_url = root.absolute_url()
path = path.replace(root_abs_url, '', 1)
path = path.strip('/')
root = aq_inner(root.restrictedTraverse(path))
relative = aq_inner(self.context).getPhysicalPath()[len(
root.getPhysicalPath()):]
if path is None:
# Add siteroot
result.append({'title': 'Root',
'url': '/'.join(root.getPhysicalPath())})
for i in range(len(relative)):
now = relative[:i + 1]
obj = aq_inner(root.restrictedTraverse(now))
if IFolderish.providedBy(obj):
if not now[-1] == 'talkback':
result.append({'title': obj.title_or_id(),
'url': root_url + '/' + '/'.join(now)})
return result
def getSections(self):
portal = self.portal_state.portal()
items = portal.getFolderContents()
for brain in items:
obj = brain.getObject()
if IFolderish.providedBy(obj):
yield obj
def navStrategy(self):
context = aq_inner(self.context)
if IFolderish.providedBy(context):
root = '/'.join(context.getPhysicalPath())
else:
parent = context.__parent__
root = '/'.join(parent.getPhysicalPath())
query = {
'path': root,
'review_state': 'published',
'portal_type': 'meetshaus.jmscontent.contentpage',
'sort_order': 'getObjPositionInParent'
}
root_obj = context.unrestrictedTraverse(root)
strategy = DefaultNavtreeStrategy(root_obj)
strategy.rootPath = '/'.join(root_obj.getPhysicalPath())
strategy.showAllParents = False
strategy.bottomLevel = 999
tree = buildFolderTree(root_obj, root_obj, query, strategy=strategy)
items = []
for c in tree['children']:
item = {}
item['item'] = c['item']
item['children'] = c.get('children', '')
item['itemid'] = c['normalized_id']
item_id = c['normalized_id']
if item_id == context.getId():
item['class'] = 'active'
else:
item['class'] = ''
items.append(item)
return items
def recurse(tree):
""" Walk through all the content on a Plone site """
for id, child in tree.contentItems():
remove_blobs(child)
if IFolderish.providedBy(child):
recurse(child)
def getBanners(self):
"""
Returns a list of objects that provide ICarouselBanner.
"""
banner_brains = []
if IFolderish.providedBy(self.context):
catalog = getToolByName(self.context, "portal_catalog")
banner_brains = catalog.searchResults(
{
"path": "/".join(self.context.getPhysicalPath()),
"object_provides": ICarouselBanner.__identifier__,
"sort_on": "getObjPositionInParent",
}
)
elif IATTopic.providedBy(self.context):
banner_brains = self.context.queryCatalog()
banner_objects = [b.getObject() for b in banner_brains]
banner_objects = [b for b in banner_objects if ICarouselBanner.providedBy(b)]
# Shuffle carousel images if needde
if self.getSettings().random_order:
shuffle(banner_objects)
return banner_objects
def upgrade(context):
old_stuff = [
'challenges',
'workspaces',
'universities',
'welcome-to-the-cnrd-virtual-center',
'people',
'library',
]
attributes_to_copy = ['title', 'description', 'text', ]
site = getSite()
# rename old stuff
for oid in old_stuff:
if oid in site.keys():
site.manage_renameObjects([oid], ['old_stuff_' + oid])
print 'renamed %s to %s' % (oid, 'old_stuff_' + oid)
else:
old_stuff.remove(oid)
print 'skipping %s' % (oid)
# cleanup products
quickinstaller = site.portal_quickinstaller
installed = quickinstaller.listInstalledProducts()
quickinstaller.uninstallProducts([p['id'] for p in installed])
quickinstaller.installProduct('cnrd.vcpolicy')
# move content to new folders
for oid in old_stuff:
old_obj = site['old_stuff_' + oid]
new_obj = site.get(oid, None)
if new_obj is None:
continue
# set attributes
for attr in attributes_to_copy:
value = getattr(old_obj, attr, None)
if value is not None:
setattr(new_obj, attr, value)
if not IFolderish.providedBy(old_obj):
continue
clip = old_obj.manage_cutObjects(old_obj.keys())
new_obj.manage_pasteObjects(clip)
print 'content moved from %s to %s' % ('old_stuff_' + oid, oid)
# remove old stuff
for oid in old_stuff:
site.manage_delObjects('old_stuff_' + oid)
print 'removed %s' % ('old_stuff_' + oid)
# rebuild the catalog
catalog = getToolByName(context, 'portal_catalog')
catalog.clearFindAndRebuild()
for challenge in site['challenges'].values():
challenge.reindexObject()
def getContainer(self):
""" Get the item for which we perform the listing
"""
context = self.context.aq_inner
if IFolderish.providedBy(context):
return context
else:
return context.aq_parent
def onObjectModified(ob, event):
"""Reindex in container"""
parent = getattr(ob, 'aq_parent', None)
if parent is None:
return
if IFolderish.providedBy(parent):
IFolderContents(parent).index(ob)
def can_configure(self):
"""
"""
context = self.context
if not IFolderish.providedBy(context):
return False
alreadyActivated = self.isFolderProfActivated()
return (not alreadyActivated)
def enabled(self):
"""Check if context is folderish or the default view of a folderish."""
context = self.context
context_state = api.content.get_view(
'plone_context_state', context, self.request)
if context_state.is_default_page():
context = context.aq_parent
return IFolderish.providedBy(context)
def render(self):
self.request.response.setHeader('Content-Type', 'application/json')
j = {}
if self.folder and IFolderish.providedBy(self.folder):
for id in FOLDER_IDS:
if hasattr(self.folder, id):
j[id] = self.get_folder_contents(id)
return json.dumps(j, sort_keys=True, indent=4)
def doRecurse(location):
for xid, child in location.contentItems():
# do something !
logger.info('id:' + str(xid))
logger.info('child:' + str(child.portal_type))
child.reindexObject()
if IFolderish.providedBy(child):
doRecurse(child)
def get_folder_contents(self, id):
"""Return list of content objects inside the object which id as a list
of dictionaries.
"""
if IFolderish.providedBy(self.folder[id]):
results = self.folder[id].listFolderContents()
else:
results = []
return self.serialize(results)
def publish(item, wfTool):
try:
wfTool.doActionFor(item, action='publish')
item.reindexObject()
except WorkflowException:
pass
if IFolderish.providedBy(item):
for itemID, subItem in item.contentItems():
publish(subItem, wfTool)
def is_folderish(brain_or_object):
"""Checks if the passed in object is folderish
:param brain_or_object: A single catalog brain or content object
:type brain_or_object: ATContentType/DexterityContentType/CatalogBrain
:returns: True if the object is folderish
:rtype: bool
"""
if hasattr(brain_or_object, "is_folderish"):
if callable(brain_or_object.is_folderish):
return brain_or_object.is_folderish()
return brain_or_object.is_folderish
return IFolderish.providedBy(get_object(brain_or_object))
def get_items(self):
"""
Get folder contents and return.
"""
context = self.context
root_nav = api.portal.get_registry_record(
name='collective.sidebar.root_nav',
default=False,
)
view_types = api.portal.get_registry_record(
name='plone.types_use_view_action_in_listings'
)
# root level navigation is enabled in settings
if root_nav:
context = api.portal.get_navigation_root(context)
# context is folderish, list content
if IFolderish.providedBy(context):
# context is an endpoint, list parents content
if INavigationEndpoint.providedBy(context):
context = context.aq_parent
else:
# context is an item, list parents content
context = context.aq_parent
contents = list()
# Can not remember what edgecase we catch here.
try:
contents = context.getFolderContents()
except Exception: # noqa: 902
pass
items = list()
for item in contents:
if self.check_item(item):
item_type = 'link-item'
url = item.getURL()
if item.portal_type in view_types:
url = url + '/view'
if item.is_folderish and self.contains_items(item):
item_type = 'link-folder'
data = {
'title': item.Title,
'title_cropped': crop(item.Title, 100),
'url': url,
'type': item_type,
}
items.append(data)
return items
def uuidToFolderishPath(context, uuid):
"""Return closest relative folderish path for the given UUID
or an empty string for the site root
"""
if uuid:
catalog = getToolByName(context, 'portal_catalog')
res = catalog and catalog.unrestrictedSearchResults(UID=uuid)
if res and len(res) == 1:
ob = res[0]._unrestrictedGetObject()
# If not folderish, use its parent instead
if not IFolderish.providedBy(ob):
ob = aq_parent(ob)
return '/'.join(ob.getPhysicalPath()[2:])
return ''
def get_editor_language(request):
"""
Get editor language override if Silvuple is installed.
"""
cached = getattr(request, "_cached_admin_language", None)
if cached:
return cached
if not ICsAdminlanguageLayer.providedBy(request):
# Add on is not active
return None
context = find_context(request)
# Filter out CSS and other non-sense
# IFolderish check includes site root
if not (IContentish.providedBy(context) or IFolderish.providedBy(context)):
# Early terminate
return None
# Check if we are the editor
if not getSecurityManager().checkPermission(
"cs.adminlanguage: ViewinAdminLanguage", context
):
# Anon visitor, normal language ->
return None
try:
# Will raise an exception if plone.app.registry is not quick installed
registry = getUtility(IRegistry)
# Will raise exception if your product add-on installer has not been run
settings = registry.forInterface(ISettings, prefix="admin_language")
except (KeyError, ComponentLookupError):
# Registry schema and actual values do not match
# Quick installer has not been run or need to rerun
# to update registry.xml values to database
return None
# Read language from settings
language = settings.adminLanguage
if language:
# Fake new language for all authenticated users
request._cached_admin_language = language
return language
return None
def _valid_context(context):
"""Walk up until finding a content item."""
# Avoid loops. The object id is used as context may not be hashable
seen = set()
while context is not None and id(aq_base(context)) not in seen:
seen.add(id(aq_base(context)))
if (IContentish.providedBy(context) or IFolderish.providedBy(context)):
return context
parent = getattr(context, '__parent__', None)
if parent is None:
parent = getattr(context, 'context', None)
context = parent
return None
def __init__(self, context, request):
super(FolderWithImagePreviewItem, self).__init__(context, request)
if IFolderish.providedBy(context):
images = api.content.find(context=context,
depth=1,
portal_type='Image',
sort_order='getObjPositionInParent',
sort_limit=1)
if len(images) > 0:
self.folder_image_info = {
'alt': context.Title(),
'title': context.Title(),
'thumb_url': images[0].getURL() + '/image_thumb',
}
def recurse_transition(self,
objs,
comment,
publication_dates,
include_children=False):
for obj in objs:
if publication_dates:
deserializer = queryMultiAdapter((obj, self.request),
IDeserializeFromJson)
deserializer(data=publication_dates)
self.wftool.doActionFor(obj, self.transition, comment=comment)
if include_children and IFolderish.providedBy(obj):
self.recurse_transition(obj.objectValues(), comment,
publication_dates, include_children)
def update(self):
super(PersonalBarViewlet, self).update()
# compute and set 'subcontext' which is the second-level
# navigation context
try:
parents = self.aq_parent.aq_inner.aq_chain
subcontext = parents[-4]
if IFolderish.providedBy(subcontext):
self.subcontext = [{
'url': item.absolute_url(),
'title': item.title_or_id(),
'selected':self.context.absolute_url()} \
for item in subcontext.objectValues()]
except IndexError:
pass
def set_recursive_language(ob, language):
"""Set the language for this object and its children in a recursive
manner
"""
if is_language_independent(ob):
ILanguage(ob).set_language(None)
elif ILanguage(ob).get_language() != language:
ILanguage(ob).set_language(language)
ITranslationManager(ob).update()
reindex_object(ob)
for child in (IFolderish.providedBy(ob) and ob.items() or ()):
if ITranslatable.providedBy(child):
set_recursive_language(child, language)
def __call__(self, expand=False):
result = {"types": {"@id": f"{self.context.absolute_url()}/@types"}}
if not expand:
return result
check_security(self.context)
vocab_factory = getUtility(
IVocabularyFactory,
name="plone.app.vocabularies.ReallyUserFriendlyTypes")
portal_types = getToolByName(self.context, "portal_types")
# allowedContentTypes already checks for permissions
constrains = IConstrainTypes(self.context, None)
if constrains:
allowed_types = constrains.getLocallyAllowedTypes()
immediately_types = constrains.getImmediatelyAddableTypes()
else:
allowed_types = [
x.getId() for x in self.context.allowedContentTypes()
]
immediately_types = allowed_types
portal = getMultiAdapter((self.context, self.request),
name="plone_portal_state").portal()
portal_url = portal.absolute_url()
# only addables if the content type is folderish
can_add = IFolderish.providedBy(self.context)
# Filter out any type that doesn't have lookupSchema. We are depended
# on that in lower level code.
ftis = [portal_types[x.value] for x in vocab_factory(self.context)]
ftis = [fti for fti in ftis if getattr(fti, "lookupSchema", None)]
result["types"] = [{
"@id":
f"{portal_url}/@types/{fti.getId()}",
"title":
translate(fti.Title(), context=self.request),
"addable":
fti.getId() in allowed_types if can_add else False,
"immediately_addable":
fti.getId() in immediately_types if can_add else False,
} for fti in ftis]
return result
def deliver(self, msg, user, recipient):
logger.info(
'MailToFolderRouter called with message %s from %s to %s' %
(msg.get('Message-ID'), user.getProperty('email'), recipient))
local_part = recipient.split('@')[0].lower()
assert len(local_part) <= 50, \
"local_part must have a reasonable length"
# Find the right context. Do that by looking up local_part
# in our local friendly-name storage, and if not found, check
# if it looks like a uid. Then look up the uid.
storage = queryUtility(IFriendlyNameStorage)
uid = storage.get(local_part, None)
if uid is None and UIDRE.match(local_part) is not None:
uid = local_part
if uid is None:
# local_part is not a uid and is not mapped onto a folder,
# this is not something we can handle.
return False
# Drop privileges to the right user
self.acl_users = getToolByName(self.site, 'acl_users')
newSecurityManager(None, user.__of__(self.acl_users))
context = api.content.get(UID=uid)
if not context:
raise NotFoundError(_("Folder not found"))
if not IFolderish.providedBy(context):
raise NotFoundError(
_("Target %s is not a folder" % context.getId()))
result = False
# Check permissions
if not getSecurityManager().checkPermission('Add portal content',
context):
raise PermissionError(
_("%s has insufficient privileges on %s" %
(user.getProperty('email'), context.getId())))
# Defer actual work to an adapter
result = IMailImportAdapter(context).add(msg)
return result
def modified(event):
"""When an object is modified, fire the ParentModifiedEvent for its
direct descendents.
"""
obj = event.object
if not (IContentish.providedBy(obj) or IComment.providedBy(obj)
or IFolderish.providedBy(obj)):
return
# IObjectModified event is called when a site is created, but before the
# catalog has been initialised which throws an AttributeError exception.
try:
children = obj.getFolderContents()
except AttributeError:
return
for child in children:
notify(ParentModifiedEvent(child.getObject()))
def list_content(content):
"""Recursively list CMF content out of the given one. ``callback``
is called every thousand items after a commit.
"""
def recurse(content):
for child in content.contentValues():
if IFolderish.providedBy(child):
for grandchild in recurse(child):
yield grandchild
yield child
if IFolderish.providedBy(content):
for child in recurse(content):
yield child
yield content
elif IContentish.providedBy(content):
yield content
def copyItemsInFolderish(folderish):
"""Will copy the items in the folder passed to this method. Recreates the bulletin, program, and department objects but copy and pastes all others"""
for object in folderish.listFolderContents():
new_obj_location = portal.restrictedTraverse(getObjCreateLocation(object))
if IFolderish.providedBy(object):
new_object = recreateObject(object, new_obj_location)
if new_object and new_object is not None:
copied_items.append(str(new_object.id))
copyItemsInFolderish(object)
else:
not_copied.append(str(object.id))
else:
if object.wl_isLocked():
object.wl_clearLocks()
copied_object = folderish.manage_copyObjects(object.id)
new_obj_location.manage_pasteObjects(copied_object)
def get_folder_contents_url(self):
"""
Get URL to folder_contents.
"""
context = self.context
parent = context.aq_parent
context_url = context.absolute_url() + '/folder_contents'
parent_url = parent.absolute_url() + '/folder_contents'
try:
if parent.default_page == context.id:
return parent_url
except AttributeError:
pass
if IFolderish.providedBy(context):
return context_url
else:
return parent_url
def reply(self):
self.check_security()
if self.params and len(self.params) > 0:
self.content_type = "application/json+schema"
try:
portal_type = self.params.pop()
return get_jsonschema_for_portal_type(portal_type,
self.context,
self.request)
except KeyError:
self.content_type = "application/json"
self.request.response.setStatus(404)
return {
'type': 'NotFound',
'message':
'Type "{}" could not be found.'.format(portal_type)
}
vocab_factory = getUtility(
IVocabularyFactory,
name="plone.app.vocabularies.ReallyUserFriendlyTypes")
portal_types = getToolByName(self.context, 'portal_types')
# allowedContentTypes already checks for permissions
allowed_types = [x.getId() for x in self.context.allowedContentTypes()]
portal = getMultiAdapter((self.context, self.request),
name='plone_portal_state').portal()
portal_url = portal.absolute_url()
# only addables if the content type is folderish
can_add = IFolderish.providedBy(self.context)
# Filter out any type that doesn't have lookupSchema. We are depended
# on that in lower level code.
ftis = [portal_types[x.value] for x in vocab_factory(self.context)]
ftis = [fti for fti in ftis if getattr(fti, 'lookupSchema', None)]
return [{
'@id': '{}/@types/{}'.format(portal_url, fti.getId()),
'title': translate(fti.Title(), context=self.request),
'addable': fti.getId() in allowed_types if can_add else False,
} for fti in ftis]
def items(self, portal_type=None):
""" Return brains for objects (of portal_type) in current folder
"""
context = Acquisition.aq_inner(self.context)
request = self.context.request
catalog = getToolByName(self.context, 'portal_catalog')
if not IFolderish.providedBy(context):
# We might be on a index_html
folder = context.aq_parent
else:
folder = self.context
query = {
'path':'/'.join(folder.getPhysicalPath()),
'sort_on': 'created',
'sort_order': 'reverse',
}
if portal_type is not None:
query['portal_type'] = portal_type
return catalog(query)
def seminars(self):
""" Return brains for SPSeminar objects in context
"""
context = Acquisition.aq_inner(self.context)
catalog = getToolByName(self.context, 'portal_catalog')
if not IFolderish.providedBy(context):
# We might be on a index_html
folder = context.aq_parent
else:
folder = self.context
query = {
'portal_type': 'SPSeminar',
'path': '/'.join(folder.getPhysicalPath()),
'sort_on': 'start',
'sort_order': 'reverse',
}
search_view = context.restrictedTraverse('@@language-fallback-search')
return search_view.search(query)
def dump_object(self, current_object, xml_parent):
self.parsed_objects += 1
is_folderish = IFolderish.providedBy(current_object)
xml_attributes = {
'meta_type': current_object.meta_type,
'id': current_object.getId(),
'path': '/'.join(current_object.getPhysicalPath()),
'folderish': str(is_folderish),
}
chain = self.portal_workflow.getChainFor(current_object)
if len(chain) > 0:
state = self.portal_workflow.getStatusOf(chain[0], current_object)
if state and 'review_state' in state:
xml_attributes['review_state'] = state['review_state']
if hasattr(current_object, 'UID'):
xml_attributes['uid'] = current_object.UID()
xml_item = self.createChild(xml_parent, self.normalizer.normalize(current_object.meta_type), None, xml_attributes)
if current_object.meta_type != 'Plone Site':
if current_object.meta_type not in self.contenttype_metadata:
self.happens('Adding new meta_type %s' % (current_object.meta_type))
self.contenttype_metadata[current_object.meta_type] = {
'schema': current_object.schema,
'meta_type': current_object.meta_type,
'fields': self.research_fields_by_schema(current_object.schema),
}
for field in self.contenttype_metadata[current_object.meta_type]['fields']:
self.dump_field(current_object, xml_item, field)
self.happens('%i/%i Added new item with id: %s' % (self.parsed_objects, self.total_objects, current_object.getId()))
if is_folderish:
xml_childs = self.createChild(xml_item, 'childs', None)
childs_ids = self.test(hasattr(current_object, 'objectIds'), current_object.objectIds(), current_object.keys())
for child_id in childs_ids:
child = current_object.get(child_id)
if child.meta_type in self.accepted_meta_types:
self.dump_object(child, xml_childs)
def dump_data(self, item):
# Given a Plone object dumps it to json
item_json = {
"metadata": {
'meta_type': item.meta_type,
'portal_type': item.portal_type,
'id': item.getId(),
'path': '/'.join(item.getPhysicalPath()),
'folderish': str(IFolderish.providedBy(item)),
}
}
chain = self.portal_workflow.getChainFor(item)
if len(chain) > 0:
state = self.portal_workflow.getStatusOf(chain[0], item)
if state and 'review_state' in state:
item_json['metadata']['status'] = state
item_json['metadata']['status']['time'] = parse_datetime(item_json['metadata']['status']['time'])["value"]
item_json['metadata']['status']['workflow'] = chain[0]
if hasattr(item, 'UID'):
item_json['metadata']['uid'] = item.UID()
if item.meta_type != 'Plone Site':
item_json['fields'] = {}
if item.meta_type not in self.meta_types.keys():
self.log('Adding new meta_type %s' % item.meta_type, 1)
self.meta_types[item.meta_type] = {
'portal_type': getattr(item, 'portal_type', None),
'fields': research_fields_by_schema(item.schema),
}
for field_name in self.meta_types[item.meta_type]['fields'].keys():
self.log("Adding field %s" % field_name, 2)
field_metadata = self.meta_types[item.meta_type]['fields'][field_name]
item_json['fields'][field_name] = self.dump_field(item, field_name, field_metadata)
return item_json
def create(self, doc_file, title='document', extension='odt'):
if not IFolderish.providedBy(self.context):
raise isNotFolderishError
container = self.context
document = api.content.create(
type='File',
title=title,
file=doc_file,
container=container,
)
filename = u'{}.{}'.format(title, extension)
document.getFile().setFilename(filename)
document.getFile().setContentType(mimetypes.guess_type(filename)[0])
return document
def get_editor_language(request):
"""
Get editor language override if Silvuple is installed.
"""
context = find_context(request)
# Filter out CSS and other non-sense
# IFolderish check includes site root
if not (IContentish.providedBy(context) or IFolderish.providedBy(context)):
# Early terminate
return None
# Check if we are the editor
if not getSecurityManager().checkPermission(
permissions.ModifyPortalContent, context):
# Anon visitor, normal language ->
return None
return FORCED_LANGUAGE
def create(self, doc_file, title='document', extension='odt'):
if not IFolderish.providedBy(self.context):
raise isNotFolderishError
container = self.context
filename = u'{}.{}'.format(title, extension)
content_type = mimetypes.guess_type(filename)[0]
file_content = NamedBlobFile(
data=doc_file,
contentType=content_type,
filename=filename,
)
document = api.content.create(
type='File',
title=title,
file=file_content,
container=container,
)
return document
def export(self, folder, recursive=False):
"""
Export content items.
Possible to do recursively nesting into the children.
:return: list of dictionaries
"""
array = []
for obj in folder.listFolderContents():
data = self.grabArchetypesData(obj)
data.update(self.grabAttributes(obj))
if recursive:
if IFolderish.providedBy(obj):
data["children"] = self.export(obj, True)
array.append(data)
return array
def dump_item(item):
# Plone object to json
if limit and self.dumpped_objects >= limit:
return
item_json = self.dump_data(item)
self.dumpped_objects += 1
self.log('%i/%i Dumpped new item with id: %s' %
(self.dumpped_objects, self.guessed_coincidences,
item.getId()))
if IFolderish.providedBy(item):
item_json['childs'] = []
childs = item.getFolderContents(content_filter)
if childs:
for child in childs:
child_json = dump_item(child.getObject())
if child_json:
item_json['childs'].append(child_json)
return item_json
def explain_tree(self, root):
results = []
children = root.listFolderContents()
for obj in children:
path = (obj.absolute_url_path()
if not getattr(obj, "getObject", None) else obj.getPath()
) # noqa
if obj.UID() not in self.uids:
if not self.pathInList(path):
# object is not in catalog results and isn't neither a
# folder in its tree
continue
obj_dict = {"path": path, "children": []}
if IFolderish.providedBy(obj):
obj_dict["children"] = self.explain_tree(obj)
results.append(obj_dict)
return results
def update(self):
super(PersonalBarViewlet, self).update()
# compute and set 'subcontext' which is the second-level
# navigation context
try:
parents = self.aq_parent.aq_inner.aq_chain
subcontext = parents[-4]
if len(parents) > 6:
selected_url = parents[-5].absolute_url()
else:
selected_url = self.context.absolute_url()
if (IFolderish.providedBy(subcontext)
and not subcontext.getExcludeFromNav()):
self.subcontext = [{
'url': item.absolute_url(),
'title': item.title_or_id(),
'selected':selected_url} \
for item in subcontext.objectValues()
if not item.exclude_from_nav()]
except (IndexError, AttributeError):
pass
def get_trasparenza_data(self, context=None):
if context is None:
context = self.context
res = []
for child in context.listFolderContents():
serializer = queryMultiAdapter((child, self.request),
ISerializeToJsonSummary)
data = serializer()
if child.portal_type == "Document":
if IFolderish.providedBy(child):
children = [
x for x in self.get_trasparenza_data(context=child)
if x.get("@type", "") in [
"Document",
]
]
if children:
data["items"] = children
res.append(data)
return res
def get_local_roles(node, p_utils):
"""Recursive generator which traverses the database and yields local
roles for all objects.
:param node: current object in the tree
:param p_utils: the plone utils tool
"""
roles = p_utils.getInheritedLocalRoles(node)
# NOTE: we don't use dict comprehension to retain compatibilty w/ py2.6
roles_info = {}
for item in roles:
key = '{0[2]} {0[3]}'.format(item)
roles_info[key] = item[1]
yield json.dumps({node.absolute_url(): roles_info})
if IFolderish.providedBy(node):
children = node.listFolderContents()
for child in children:
for obj in get_local_roles(child, p_utils):
yield obj
def update(self):
# We will need the banner viewlet dimensions if we find a banner
registry = getUtility(IRegistry)
self.settings = registry.forInterface(IBannerViewletSettings)
logger.info("starting banner search at %s " % self.context )
if IFolderish.providedBy(self.context):
logger.info("findBannerImageFor(self) %s " % self.context )
self.findBannerImageFor(self.context)
else:
if IBannerImage.providedBy(self.context):
logger.info("%s provides IBannerImage" % self.context )
banner = IBannerImage(self.context)
if banner.banner_image:
logger.info("banner_image defined by context %s" % self.context)
self.banners = [banner]
self.available = True
return
parent = self.context.aq_parent
logger.info("findBannerImageFor(parent) %s " % parent )
self.findBannerImageFor(parent)
