class ContentInMissionReport(grok.Viewlet):
grok.context(IContentish)
grok.viewletmanager(manager.IBelowContentTitle)
grok.template('content_in_mission_report')
grok.layer(IProductSpecific)
def available(self):
if not (IATFile.providedBy(self.context)
or IATBlobFile.providedBy(self.context)):
return False
return bool(self.mission_report())
def mission_report(self):
parent = aq_parent(self.context)
if IMissionReport.providedBy(parent):
return parent
return None
class Tmpls(grok.Viewlet):
grok.context(Interface)
grok.name(u"coppe.govupload.tmpls")
grok.require("cmf.AddPortalContent")
grok.template("tmpls")
grok.viewletmanager(IHtmlHead)
def enabled(self):
"""
Only renders the templates if the context is a folderish or
the default view of a folderish
"""
context = self.context
context_state = getMultiAdapter((context, self.request),
name=u'plone_context_state')
if context_state.is_default_page():
context = context.aq_parent
return IFolderish.providedBy(context)
class RedirectorViewlet(grok.Viewlet):
"""Viewlet which adds the redirects for the IRedirector."""
grok.name('redirector')
grok.context(Interface)
grok.viewletmanager(IAboveContentTitle)
grok.require('zope2.View')
JS_TEMPLATE = '''
<script type="text/javascript" class="redirector">
$(function() {
if ('%(url)s'.split(':')[0] == 'oc') {
window.location = '%(url)s';
} else {
window.setTimeout("window.open('%(url)s', '%(target)s');", %(timeout)s);
}
});
</script>
'''
def view_name(self):
view = getattr(self, 'view', None)
if view:
return getattr(view, '__name__', None)
def render(self):
redirector = IRedirector(self.request)
# If we're on the CSRF confirm-action dialog, we don't want to
# trigger any redirects.
if self.view_name() == 'confirm-action':
# Consume the redirector cookie to avoid unconditional redirects
# immediately *after* the confirm-action view. If the user
# confirms, the redirector cookies will be set again.
redirector.get_redirects(remove=True)
return ''
redirects = redirector.get_redirects(remove=True)
html = []
for redirect in redirects:
html.append(RedirectorViewlet.JS_TEMPLATE % redirect)
return ''.join(html)
class CollectionContentFilter(grok.Viewlet):
grok.context(IATTopic)
grok.viewletmanager(manager.IHtmlHead)
grok.layer(IProductSpecific)
def available(self):
return True
def render(self):
searchableText = self.request.get('contentFilterSearchableText', '')
if searchableText:
contentFilter = dict(self.request.get('contentFilter', {}))
contentFilter['SearchableText'] = searchableText
self.request.set('contentFilter', contentFilter)
IStatusMessage(self.request).add(
_(u'search_results_notification',
default=u'Displaying search results for "${searchableText}"',
mapping={'searchableText': searchableText.decode('utf-8')}))
return ''
class PersonalCampaignPageToolbarViewlet(grok.Viewlet):
grok.name('collective.salesforce.fundraising.PersonalCampaignPageToolbar')
grok.require('zope2.View')
grok.context(IPersonalCampaignPage)
grok.template('personal-campaign-toolbar')
grok.viewletmanager(IPortalHeader)
def update(self):
# FIXME - I tried for hours to get checkPermission from the security manager to work to no avail... falling back to old school method
pm = getToolByName(self.context, 'portal_membership')
self.can_edit = pm.checkPermission(
'collective.salesforce.fundraising: Edit Personal Campaign',
self.context)
self.can_view_donors = pm.checkPermission(
'collective.salesforce.fundraising: View Personal Campaign Donors',
self.context)
self.can_promote = pm.checkPermission(
'collective.salesforce.fundraising: Promote Personal Campaign',
self.context)
class ListTagsNews(viewletBase):
grok.name('genweb.listtags')
grok.context(INewsItem)
grok.template('listtags')
grok.viewletmanager(IAboveContentTitle)
grok.require('genweb.authenticated')
grok.layer(IUlearnTheme)
def isTagFollowed(self, category):
portal = getSite()
current_user = api.user.get_current()
userid = current_user.id
soup_tags = get_soup('user_subscribed_tags', portal)
tags_soup = [r for r in soup_tags.query(Eq('id', userid))]
if tags_soup:
tags = tags_soup[0].attrs['tags']
return True if category in tags else False
else:
return False
class CheckedOutViewlet(grok.Viewlet):
grok.viewletmanager(IAboveContent)
grok.context(IDocumentSchema)
grok.view(IViewView)
grok.require('zope2.View')
def update(self):
manager = queryMultiAdapter((self.context, self.request),
ICheckinCheckoutManager)
if not manager:
self.available = False
elif not manager.checked_out():
self.available = False
else:
self.available = True
info = getUtility(IContactInformation)
owner_id = manager.checked_out()
self.checkout_owner = info.render_link(owner_id)
class TimeLineViewlet(grok.Viewlet):
grok.context(ISnippet)
grok.name('collective.giesing.TimeLineViewlet')
grok.require('zope2.View')
grok.viewletmanager(IBelowContent)
def getTimeLine(self):
cat = getToolByName(self.context, 'portal_catalog')
query = dict(
object_provides='collective.giesing.snippet.ISnippet',
timetag=dict(query=[
self.context.timetag,
], range='min'),
sort_on='timetag',
)
future = [x for x in cat(query)]
query['timetag']['range'] = 'max'
past = [x for x in cat(query)]
timeline = past[-3:-1] + future[:3]
return timeline
class ReviewResultForAuthor_IBelowContent_IArticle(grok.Viewlet):
grok.viewletmanager(IBelowContent)
grok.context(IArticle)
template = ViewPageTemplateFile('template/reviewResultForAuthor.pt')
def currentUserId(self):
user = api.user.get_current()
if user:
return user.getId()
def getState(self):
return api.content.get_state(obj=self.context)
def render(self):
self.getView = api.content.get_view(
name='view',
context=self.context,
request=self.context.REQUEST,
)
return self.template()
class statement_viewlet(grok.Viewlet):
grok.context(IStatement)
grok.require('zope2.View')
grok.template('statement_viewlet')
grok.viewletmanager(IAboveContent)
@property
def catalog(self):
return getToolByName(self.context, 'portal_catalog')
def contents(self):
brains = self.catalog.unrestrictedSearchResults(
path={
'query': '/'.join(self.context.getPhysicalPath()),
'depth': 1
},
portal_type='interfaithclimate.signup.signature',
review_state='published')[:15]
brains2 = self.catalog.unrestrictedSearchResults(
path={
'query': '/'.join(self.context.getPhysicalPath()),
'depth': 0
})
results = []
path = ''
for brain in brains:
obj = brain._unrestrictedGetObject()
results.append({
'name':
str(obj.first_name) + ' ' + str(obj.last_name),
'designation':
obj.designation,
'organization':
obj.organization,
'location':
str(obj.country)
})
for brain in brains2:
path = brain.getPath()
return [results, path]
class slider(viewletBase):
grok.context(IPloneSiteRoot)
grok.name('vilaix.slider')
grok.template('slider')
grok.viewletmanager(IPortalHeader)
grok.layer(IVilaixTheme)
def sliderItems(self):
catalog = getToolByName(self.context, 'portal_catalog')
utool = getToolByName(self.context, 'portal_url')
path = '{0}/material-multimedia/sliders'.format(utool.getPortalPath()),
now = DateTime()
items = catalog.searchResults(portal_type='Slider',
path=dict(query=path, depth=1),
review_state='published',
Subject='principal',
expires={
'query': now,
'range': 'min',
},
sort_on='getObjPositionInParent')
results = []
for item in items:
results.append({
'img':
'%s/@@images/image' % (item.getURL()),
'title':
item.Title,
'text':
item.Description,
'alt':
item.getObject().alt,
'url':
item.getObject().remoteUrl,
'target':
item.open_link_in_new_window and '_blank' or None,
})
return results
class TemplatesViewlet(BaseViewlet):
permission = 'cmf.ModifyPortalContent'
grok.context(IFolderish)
grok.require(permission)
grok.name('seantis.reservation.mailviewlet')
grok.viewletmanager(OverviewletManager)
grok.order(4)
_template = grok.PageTemplateFile('templates/email_templates.pt')
@view.memoize
def templates(self):
templates = [
t.getObject() for t in utils.portal_type_in_context(
self.context, portal_type='seantis.reservation.emailtemplate')
]
return sorted(templates, key=lambda t: t.title)
def links(self, template=None):
# global links
if not template:
baseurl = self.context.absolute_url()
return [(_(u'Add email template'),
baseurl + '/++add++seantis.reservation.emailtemplate')]
# template specific links
links = []
baseurl = template.absolute_url()
links.append((_(u'Edit'), baseurl + '/edit'))
links.append((_(u'Delete'), baseurl + '/delete_confirmation'))
return links
def render(self, **kwargs):
return self._template.render(self)
class JavascriptSettings(BaseViewlet):
grok.context(Interface)
grok.viewletmanager(IHtmlHead)
@property
def language(self):
context = self.context.aq_inner
portal_state = getMultiAdapter((context, self.request),
name=u'plone_portal_state')
return portal_state.language()
@property
def settings(self):
return {'language': self.language}
def render(self):
return TEMPLATE % {
'name': 'seantis_reservation_variables',
'variables': json.dumps(self.settings)
}
class socialtoolsViewlet(viewletBase):
grok.name('genweb.socialtools')
grok.template('socialtools')
grok.viewletmanager(IAboveContentTitle)
grok.layer(IGenwebServeisticLayer)
def getData(self):
Title = aq_inner(self.context).Title()
contextURL = self.context.absolute_url()
return dict(Title=Title, URL=contextURL)
def is_social_tools_enabled(self):
return not self.genweb_config().treu_icones_xarxes_socials
def is_servei(self):
return IServeiTIC.providedBy(self.context)
@property
def url_rss(self):
return "{0}/notificacions/RSS".format(
self.context.absolute_url()) if self.is_servei() else ''
class CheckedOutViewlet(grok.Viewlet):
"""A viewlet which shows a statusmessage like message:
`This item is being checked out by User XY` when a document
is checked out."""
grok.viewletmanager(IAboveContent)
grok.context(IDocumentSchema)
grok.view(IViewView)
grok.require('zope2.View')
def update(self):
manager = queryMultiAdapter((self.context, self.request),
ICheckinCheckoutManager)
if not manager:
self.available = False
elif not manager.get_checked_out_by():
self.available = False
else:
self.available = True
self.checkout_by_link = Actor.user(
manager.get_checked_out_by()).get_link()
class Homepage2Slider(grok.Viewlet):
grok.context(IHomepage2)
grok.view(Index)
grok.viewletmanager(manager.IPortalTop)
grok.template('homepage2slider')
grok.layer(IProductSpecific)
def available(self):
return True
def slider_items(self):
if not self.context.slider_items:
return []
return [i.to_object for i in self.context.slider_items]
def get_image_tag(self, obj):
scales = obj.restrictedTraverse('@@images')
image = scales.scale('carousel_image', width=782, height=330)
placeholder = '<img src="http://placehold.it/782x330"/>'
if not image:
return placeholder
return image.tag()
class LocationViewlet(grok.Viewlet):
grok.context(ISnippet)
grok.name('collective.giesing.LocationViewlet')
grok.require('zope2.View')
grok.viewletmanager(IBelowContent)
def getSnippets(self):
intids = getUtility(IIntIds)
relcatalog = getUtility(ICatalog)
snippets = [
intids.getObject(rv.from_id) for rv in relcatalog.findRelations(
{'to_id': self.context.locationtag.to_id})
]
timeline = [
dict(Title=obj.Title(),
getURL=obj.absolute_url(),
storyline=obj.aq_parent.Title(),
timetag=obj.timetag) for obj in snippets
]
timeline.sort(key=lambda x: x['timetag'])
return timeline
class gwLanguageSelectorForRoot(gwLanguageSelectorBase):
# Show link to languages published in control panel
grok.context(IPloneSiteRoot)
grok.viewletmanager(gwLanguageSelectorViewletManager)
# grok.layer(IGenwebLayer)
def languages(self):
languages_info = super(gwLanguageSelectorForRoot, self).languages()
idiomes_publicats = genweb_config().idiomes_publicats
redirect_to_root = genweb_config().languages_link_to_root
user_has_permission_at_root = havePermissionAtRoot()
results = []
filtered_languages = [lang_info for lang_info in languages_info if user_has_permission_at_root or lang_info['code'] in idiomes_publicats]
for lang_info in filtered_languages:
# Avoid to modify the original language dict
data = lang_info.copy()
data['translated'] = True
query_extras = {
'set_language': data['code'],
}
if not redirect_to_root:
post_path = getPostPath(self.context, self.request)
if post_path:
query_extras['post_path'] = post_path
data['url'] = addQuery(
self.request,
self.context.absolute_url(),
**query_extras
)
else: # Redirect to root when make a language click
data['url'] = self.portal_url() + '?set_language=' + data['code']
results.append(data)
return results
class gwPersonalBarViewlet(PersonalBarViewlet, viewletBase):
grok.name('genweb.personalbar')
grok.viewletmanager(IPortalTop)
grok.layer(IVilaixTheme)
index = ViewPageTemplateFile('viewlets_templates/personal_bar.pt')
def showRootFolderLink(self):
return havePermissionAtRoot()
def canManageSite(self):
return checkPermission("plone.app.controlpanel.Overview",
self.portal())
def getPortraitMini(self):
pm = getToolByName(self.portal(), 'portal_membership')
return pm.getPersonalPortrait().absolute_url()
def logout_link(self):
if HAS_CAS:
return '{}/cas_logout'.format(self.portal_url)
else:
return '{}/logout'.format(self.portal_url)
class QuestionInfo(silvaviews.Viewlet):
grok.context(IPollQuestion)
grok.view(Publish)
grok.viewletmanager(silvaforms.SMIFormPortlets)
grok.order(40)
def available(self):
return self.version is not None
def update(self):
self.version = self.context.get_viewable()
if self.version is not None:
dates = self.request.locale.dates
format = dates.getFormatter('dateTime', 'short').format
convert = lambda d: d is not None and format(d) or None
self.question_start_datetime = convert(
self.version.question_start_datetime())
self.question_end_datetime = convert(
self.version.question_end_datetime())
self.result_start_datetime = convert(
self.version.result_start_datetime())
self.result_end_datetime = convert(
self.version.result_end_datetime())
class HeadTitleViewlet(grok.Viewlet):
grok.context(IItem)
grok.layer(ISantaTemplatesLayer)
grok.name('santa.head.title')
grok.require('zope2.View')
grok.template('head-title')
grok.viewletmanager(IPortalHeader)
def head(self):
catalog = getToolByName(self.context, 'portal_catalog')
portal_state = getMultiAdapter((self.context, self.request),
name="plone_portal_state")
portal = portal_state.portal()
items = {
'title': portal.title,
'description': portal.description,
'portal_url': portal.absolute_url(),
}
head = portal.get('foundation')
if head:
query = {
'path': {
'query': '/'.join(head.getPhysicalPath()),
'depth': 1
}
}
brains = catalog(query)
if len(brains) > 0:
brain = brains[0]
title = brain.Title
description = brain.Description
if title:
items.update({'title': title})
if description:
items.update({'description': description})
return items
class FolderViewlet(FeedViewlet):
grok.name('santa.viewlet.folder')
grok.viewletmanager(SantaFolderViewletManager)
def parent_path(self):
oid = self.context.id
if oid == 'cases':
oid = 'partners'
portal_state = getMultiAdapter((self.context, self.request),
name="plone_portal_state")
portal = portal_state.portal()
return '{0}/{1}'.format(
'/'.join(portal.getPhysicalPath()),
oid,
)
def _path(self):
oid = self.context.id
if oid == 'cases':
portal_state = getMultiAdapter((self.context, self.request),
name="plone_portal_state")
portal = portal_state.portal()
return '{0}/cases'.format('/'.join(portal.getPhysicalPath()), )
else:
return super(FolderViewlet, self)._path()
def has_date(self):
oid = self.context.id
if oid != 'inquiries':
return True
def items(self):
oid = self.context.id
limit = 5
if oid == 'news':
brains = self._brains(interface=IATNewsItem, limit=limit)
if oid == 'events':
brains = self._brains(interface=IATEvent,
sort_on='start',
limit=limit)
if oid == 'partners':
brains = self._brains(interface=IPartner, limit=limit)
if oid == 'cases':
brains = self._brains(interface=IATImage,
path=self.parent_path(),
depth=None,
limit=limit)
if oid == 'inquiries':
brains = self._brains(interface=IPloneFormGenForm,
sort_on=None,
limit=None)
if oid == 'foundation':
return None
return self._items(brains)
def show_docs(self):
oid = self.context.id
if oid == 'foundation':
return True
return super(FolderViewlet, self).show_docs()
def show_description(self):
oid = self.context.id
if oid == 'foundation':
return True
def _document(self):
catalog = getToolByName(self.context, 'portal_catalog')
languages = getToolByName(self.context, 'portal_languages')
oids = languages.supported_langs
query = {
'path': {
'query': '/'.join(self.context.getPhysicalPath()),
'depth': 1,
},
'object_provides': IATDocument.__identifier__,
}
brains = catalog(query)
if brains:
brain = brains[0]
bid = brain.id
if bid in oids:
return brain
def title(self):
doc = self._document()
return doc and doc.Title or self.context.Title()
def description(self):
doc = self._document()
return doc and doc.Description or self.context.Description()
def url(self):
return self.context.absolute_url()
def text(self):
doc = self._document()
if doc:
obj = doc.getObject()
return obj.getField('text').get(obj)
grok.order(30)
class Boutique(grok.Viewlet):
grok.order(40)
def getRandomBoutiqueItem(self):
"""
Get one random boutiqueItem
"""
cat = getToolByName(self.context, 'portal_catalog')
results = cat.searchResults(portal_type=['BoutiqueItem'],
review_state='published')
results = list(results)
random.shuffle(results)
for boutiqueItem in results:
if "%s/" % boutiqueItem.getURL() not in self.request.URL and boutiqueItem.getURL() != self.request.URL:
return boutiqueItem.getObject()
return None
def getAllBoutiqueItemsView(self):
"""
Get the link to all boutique items
"""
utool = getToolByName(self.context, 'portal_url')
return '%s/shop' % utool()
# register all viewlets in this viewlet manager:
grok.viewletmanager(OffresViewletManager)
hash_json = json.dumps([self.context.absolute_url(),
self.form_values],
sort_keys=True)
return hashlib.md5(hash_json).hexdigest()
@property
def cookie_key(self):
""" Returns a hash to identify the cookie """
return hashlib.md5(self.context.absolute_url()).hexdigest()
@property
def form_values(self):
"""
Returns the form dictionnary of the request to a format that JSON
can handle
"""
form = {}
for key, value in self.request.form.items():
key = re.sub('\[\]', '', key)
if isinstance(value, datetime.date):
value = value.strftime('%d/%m/%Y')
form[key] = value
return form
class HebergementListingViewletManager(grok.ViewletManager):
grok.name('gites.heblisting')
# register all viewlets in this viewlet manager:
grok.viewletmanager(HebergementListingViewletManager)
grok.templatedir('templates')
grok.context(interface.Interface)
class HeaderViewletManager(grok.ViewletManager):
grok.name('gites.header')
class TopHeaderViewlet(grok.Viewlet):
grok.order(10)
class MainHeaderViewlet(grok.Viewlet):
grok.order(20)
def update(self):
self.form = BasicForm(self.context, self.request)
self.form.update()
# Defines the placeholder for some field
widgets_placeholder = ('fromDate', 'toDate', 'nearTo')
for widget in self.form.widgets:
if widget in widgets_placeholder:
label = self.form.widgets[widget].label
self.form.widgets[widget].placeholder = label
# register all viewlets in this viewlet manager:
grok.viewletmanager(HeaderViewletManager)
class Tmpls(grok.Viewlet):
grok.context(IFolder)
grok.name(u"collective.upload.tmpls")
grok.require("cmf.AddPortalContent")
grok.template("tmpls")
grok.viewletmanager(IHtmlHead)
# -*- coding: utf-8 -*-
from five import grok
from zope import interface
from gites.core.interfaces import IMapViewletManager
from gites.map.browser.interfaces import IGitesMap
grok.templatedir('templates')
grok.context(interface.Interface)
class MapViewletManager(grok.ViewletManager):
grok.name('gites.mapviewlet')
grok.provides(IMapViewletManager)
grok.layer(IGitesMap)
# register all viewlets in this viewlet manager:
grok.viewletmanager(MapViewletManager)
from gomobiletheme.mobipublic import MessageFactory as _
# Layer for which against all our viewlets are registered
from interfaces import IThemeLayer
# Viewlets are on all content by default.
grok.context(Interface)
# Use templates directory to search for templates.
grok.templatedir('templates')
# Viewlets are active only when gomobiletheme.basic theme layer is activated
grok.layer(IThemeLayer)
# All viewlets are registered against this dummy viewlet manager
grok.viewletmanager(base.MainViewletManager)
class Head(base.Head):
def favicon_url(self):
""" Get url for favicon
"""
portal_state = getView(self.context, self.request, "plone_portal_state")
self.portal_url = portal_state.portal_url()
return self.portal_url + "/favicon.ico"
class Logo(base.Logo):
""" Render site logo with link back to the site root.
Logo will be automatically resized in the case of
the mobile screen is very small.
try:
appendtourl = '/'.join(append_path) + \
'?' + make_query(formvariables, dict(set_language=data['code']))
except UnicodeError:
appendtourl = '/'.join(append_path) + '?set_language=' + data['code']
if data['translated']:
trans = translations[data['code']][0]
container = aq_parent(trans)
if isDefaultPage(container, trans):
trans = container
state = getMultiAdapter((trans, self.request),
name='plone_context_state')
data['url'] = state.view_url() + appendtourl
else:
container = aq_parent(context)
if isDefaultPage(container, context):
context = container
state = getMultiAdapter((context, self.request),
name='plone_context_state')
try:
data['url'] = state.view_url() + appendtourl
except AttributeError:
data['url'] = context.absolute_url() + appendtourl
return results
grok.viewletmanager(IPortalHeader)
class TimeframeViewlet(BaseViewlet):
permission = 'cmf.ModifyPortalContent'
grok.context(IFolderish)
grok.require(permission)
grok.name('seantis.reservation.timeframeviewlet')
grok.viewletmanager(OverviewletManager)
grok.order(3)
_template = grok.PageTemplateFile('templates/timeframes.pt')
@property
def workflowTool(self):
return getToolByName(self.context, "portal_workflow")
@view.memoize
def timeframes(self):
frames = [t.getObject() for t in timeframes_in_context(self.context)]
return sorted(frames, key=lambda f: f.start)
@property
@view.memoize
def titles(self):
"""Returns a dict with titles keyed by review_state. The workflow-tool
has a getTitleForStateOnType function which should do that but
it does not return updated values for me, just some old ones.
The listWFStatesByTitle function on the other hand contains
the right information and I will just use that instead.
Once this breaks I'll read the source of the workflow tool, until this
happens I'm off to do useful things.
"""
titles = self.workflowTool.listWFStatesByTitle()
return dict(((t[1], t[0]) for t in titles))
def state(self, timeframe):
state = self.workflowTool.getStatusOf(
"timeframe_workflow", timeframe
)['review_state']
title = self.titles[state]
return state, utils.translate_workflow(
self.context, self.request, title
)
def render(self, **kwargs):
if self.context is None:
return u''
return self._template.render(self)
def visible(self, frame):
state = self.state(frame)[0]
return state == 'visible'
def links(self, frame=None):
# global links
if not frame:
baseurl = self.context.absolute_url()
return [(_(u'Add timeframe'),
baseurl + '/++add++seantis.reservation.timeframe')]
# frame specific links
links = []
action_tool = getToolByName(frame, 'portal_actions')
actions = action_tool.listFilteredActionsFor(frame)['workflow']
for action in actions:
if action['visible'] and action['available']:
action['title'] = utils.translate_workflow(
self.context, self.request, action['title']
)
links.append((action['title'], action['url']))
baseurl = frame.absolute_url()
links.append((_(u'Edit'), baseurl + '/edit'))
links.append((_(u'Delete'), baseurl + '/delete_confirmation'))
return links
class InternalReviewerDesktop_IBelowContent_IProfile(grok.Viewlet):
grok.viewletmanager(IBelowContent)
grok.context(IProfile)
grok.require('cmf.AddPortalContent')
template = ViewPageTemplateFile('template/internalReviewerDesktop.pt')
def reviewStateCount(self):
# waitingAssignEx: 待指定委員
self.waitingAssignEx = 0
# waitingForReview: 審查中
self.waitingForReview = 0
# endReview: 審查完
self.endReview = 0
catalog = self.context.portal_catalog
currentUserId = api.user.get_current().getId()
profileBrain = catalog({'Type': 'Profile', 'Creator': currentUserId})
if len(profileBrain) == 0:
return
profile = profileBrain[0]
brain = catalog({
'Type': 'Article',
'review_state': ['internalAssigned', 'retrial'],
'assignInternalReviewer': profile.id
})
# import pdb; pdb.set_trace()
if len(brain) == 0:
return
# 計算待指定委員
for item in brain:
count = 0
if item.assignExternalReviewer1:
count += 1
if item.assignExternalReviewer2:
count += 1
if item.assignExternalReviewer3:
count += 1
if count < 2:
self.waitingAssignEx += 1
# 計算審查中, 審查完
for item in brain:
itemObj = item.getObject()
yes, no = 0, 0
if bool(item.assignExternalReviewer1) and bool(
itemObj.reviewConfirm1):
yes += 1
elif bool(item.assignExternalReviewer1) and not bool(
itemObj.reviewConfirm1):
no += 1
if bool(item.assignExternalReviewer2) and bool(
itemObj.reviewConfirm2):
yes += 1
elif bool(item.assignExternalReviewer2) and not bool(
itemObj.reviewConfirm2):
no += 1
if bool(item.assignExternalReviewer3) and bool(
itemObj.reviewConfirm3):
yes += 1
elif bool(item.assignExternalReviewer3) and not bool(
itemObj.reviewConfirm3):
no += 1
if no > 0:
self.waitingForReview += 1
if yes > 1 and no == 0:
self.endReview += 1
return
def render(self):
self.reviewStateCount()
self.getView = api.content.get_view(
name='view',
context=self.context,
request=self.context.REQUEST,
)
return self.template()
class HeadInsert(silvaviews.Viewlet):
""" Custom head insertions
"""
grok.viewletmanager(porto.HTMLHeadInsert)
from Products.CMFCore.utils import getToolByName
from gites.db.interfaces import IHebergement
grok.templatedir('templates')
grok.context(IHebergement)
class HebergementViewletManager(grok.ViewletManager):
grok.name('gites.hebergement')
class ButtonsViewlet(grok.Viewlet):
grok.order(10)
def backButtonAvailable(self):
"""
Show back button only if we were already on gites website
"""
referer = self.request.get('HTTP_REFERER')
if not referer:
return False
portalUrl = getToolByName(self.context, 'portal_url')()
if referer and referer.startswith(portalUrl):
return True
return False
grok.viewletmanager(HebergementViewletManager)
#   ==
# but we must remain XML compatible
return text.replace(" ", " ")
class MainViewletManager(grok.ViewletManager):
""" This viewlet manager is responsible for all gomobiletheme.basic viewlet registrations.
Viewlets are directly referred in main_template.pt by viewlet name,
thus overriding Plone behavior to go through ViewletManager render step.
"""
grok.name('gomobiletheme.basic.viewletmanager')
# Set viewlet manager default to all following viewlets
grok.viewletmanager(MainViewletManager)
class MobileViewletBase(grok.Viewlet):
"""
Superclass for all mobile viewlets. Provides some helper methods.
It is not strictly necessary to inherit other viewlets from this.
"""
grok.baseclass()
def is_plone4(self):
""" Allow major viewlet change compatiblity between Plone versions from tempalte """
return PLONE_VERSION > 3
if cal == ['non actif'] or cal == ['bloque']:
return False
else:
return True
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
for heb in getHebergementsForProprio(self.context, session):
return (heb.heb_calendrier_proprio != 'non actif')
def isBlocked(self):
"""
See if proprio calendars are blocked (due to 40 days delay)
"""
cal = self.request.get('form.widgets.calendarConfig')
if cal is not None:
return (cal == ['bloque'])
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
for heb in getHebergementsForProprio(self.context, session):
if heb.heb_calendrier_proprio == 'bloque':
return True
return False
@memoize
def getGitesForProprio(self):
return getUtility(IVocabularyFactory, name='proprio.hebergements')(self.context)
# register all viewlets in this viewlet manager:
grok.viewletmanager(ZoneMembreViewletManager)
if linkLang == '' or linkLang == currentLanguage:
visualImage = {'imagesrc': image.getURL(),
'href': relatedItem.remoteUrl,
'title': relatedItem.Title(),
'description': relatedItem.Description()}
results.append(visualImage)
return results
def getCarouselPackages(self):
cat = getToolByName(self.context, 'portal_catalog')
packages = cat.searchResults(portal_type='Package')
results = []
for brain in packages:
package = brain.getObject()
showInCarousel = getattr(package, 'showInCarousel', False)
if showInCarousel:
url = package.absolute_url()
results.append({'imagesrc': "%s/largePhoto" % url,
'href': url,
'title': package.Title(),
'description': package.Description()})
return results
def getCarouselInfos(self):
results = self.getCarouselPackages() + self.getVisualImages()
random.shuffle(results)
return results
# register all viewlets in this viewlet manager:
grok.viewletmanager(ProduitPackageViewletManager)
from five import grok
from plone.app.layout.viewlets.interfaces import IPortalTop
from zope.interface import Interface
from Products.CMFCore.utils import getToolByName
from zope.component import getMultiAdapter
from hejasverige.content.interfaces import IMyPages
grok.viewletmanager(IPortalTop)
grok.context(Interface)
grok.templatedir("templates")
class MenuBar(grok.Viewlet):
""" Create a viewlet for transactions
"""
grok.name("menubar")
def update(self):
self.mymenu_actions = []
mship = getToolByName(self.context, "portal_membership")
if mship.isAnonymousUser():
return
if not IMyPages.providedBy(self.__parent__):
return
super(MenuBar, self).update()
context_state = getMultiAdapter((self.context, self.request), name=u"plone_context_state")
class ResponseView(grok.Viewlet, Base):
grok.context(ITask)
grok.name("opengever.task.response.view")
grok.viewletmanager(BeneathTask)
grok.order(1)
def __init__(self, context, request, view, manager):
grok.Viewlet.__init__(self, context, request, view, manager)
Base.__init__(self, context, request)
def get_css_class(self, item):
"""used for display icons in the view"""
return get_css_class(item)
def get_added_objects(self, response):
# Some relations may not have an added_object attribute...
try:
response.added_object
except AttributeError:
return None
# .. and sometimes it may be empty.
if not response.added_object:
return None
# Support for multiple added objects was added, so added_object may
# be a list of relations, but could also be a relation directly.
if hasattr(response.added_object, '__iter__'):
relations = response.added_object
else:
relations = [response.added_object]
# Return the target objects, not the relations.
objects = []
for rel in relations:
objects.append(rel.to_object)
return objects
def get_added_successor(self, response):
try:
response.successor_oguid
except AttributeError:
return None
if response.successor_oguid:
query = getUtility(ITaskQuery)
return query.get_task_by_oguid(response.successor_oguid)
else:
return None
def convert_change_values(self, fieldname, value):
if fieldname == 'responsible_client':
info = getUtility(IContactInformation)
client = info.get_client_by_id(value)
if client:
return client.title
else:
return value
elif fieldname == 'responsible':
info = getUtility(IContactInformation)
return info.render_link(value)
elif isinstance(value, datetime.date):
trans_service = getToolByName(self.context, 'translation_service')
return trans_service.toLocalizedTime(
datetime.datetime(value.year, value.month, value.day))
return value
# but we must remain XML compatible
return text.replace(" ", " ")
class MainViewletManager(grok.ViewletManager):
""" This viewlet manager is responsible for all gomobiletheme.basic viewlet registrations.
Viewlets are directly referred in main_template.pt by viewlet name,
thus overriding Plone behavior to go through ViewletManager render step.
"""
grok.name("gomobiletheme.basic.viewletmanager")
# Set viewlet manager default to all following viewlets
grok.viewletmanager(MainViewletManager)
class MobileViewletBase(grok.Viewlet):
"""
Superclass for all mobile viewlets. Provides some helper methods.
It is not strictly necessary to inherit other viewlets from this.
"""
grok.baseclass()
def is_plone4(self):
""" Allow major viewlet change compatiblity between Plone versions from tempalte """
return PLONE_VERSION > 3
class Modern(grok.Viewlet):
grok.order(10)
grok.view(Painting)
grok.viewletmanager(Art)
class Classic(grok.Viewlet):
grok.order(20)
grok.view(Painting)
grok.viewletmanager(Art)
from gites.core.browser.search import BasicForm
grok.templatedir('templates')
grok.context(interface.Interface)
class RechercherViewletManager(grok.ViewletManager):
grok.name('gites.rechercher')
class RechercherViewlet(grok.Viewlet):
grok.order(10)
def update(self):
self.form = BasicForm(self.context, self.request)
self.form.update()
# Defines the placeholder for some field
widgets_placeholder = ('fromDate', 'toDate', 'nearTo')
for widget in self.form.widgets:
if widget in widgets_placeholder:
label = self.form.widgets[widget].label
self.form.widgets[widget].placeholder = label
# register all viewlets in this viewlet manager:
grok.viewletmanager(RechercherViewletManager)
class MonthlyStatViewlet(StatViewlet):
grok.order(2)
title = u'Statistique par mois'
groupType = 'month'
class YearlyStatViewlet(StatViewlet):
grok.order(3)
title = u'Statistique par an'
groupType = 'year'
class StatsContentViewletManager(grok.ViewletManager):
grok.name('stats.content')
grok.viewletmanager(StatsContentViewletManager)
class StatForm(Form):
"""formulaire"""
fields = field.Fields(IHebFilterForm)
ignoreContext = True
hebPk = None
def findHeb(self, hebPk):
wrapper = getSAWrapper('gites_wallons')
session = wrapper.session
query = session.query(Hebergement)
query = query.filter(Hebergement.heb_pk == hebPk)
return query.first()
