class SimpleConsumer(Consumer):
grok.name("my.queue")
connection_id = "test.connection"
queue = "my.queue"
marker = IMessage
class PickleProducer(Producer):
grok.name("my.picklequeue")
connection_id = "test.connection"
queue = "my.picklequeue"
serializer = "application/x-python-serialize"
class KeywordSymmetricDifference(KeywordOperator):
"""Compute symmetric difference of keywords."""
grok.name('symmetric_difference')
def __call__(self, operand2):
return self.operand1.symmetric_difference(operand2)
class SimpleProducer(Producer):
grok.name("my.queue")
connection_id = "test.connection"
queue = "my.queue"
serializer = "text/plain"
class Message(zeit.push.message.Message):
grok.name('twitter')
@property
def text(self):
text = self.config.get('override_text')
if not text: # BBB
self.get_text_from = 'short_text'
text = super(Message, self).text
return text
@property
def url(self):
return self.add_query_params(
super().url,
wt_zmc='sm.int.zonaudev.twitter.ref.zeitde.redpost.link.x',
utm_medium='sm',
utm_source='twitter_zonaudev_int',
utm_campaign='ref',
utm_content='zeitde_redpost_link_x',
)
@property
def log_message_details(self):
return 'Account %s' % self.config.get('account', '-')
class KeywordIntersection(KeywordOperator):
"""Intersect keywords."""
grok.name('intersection')
def __call__(self, operand2):
return self.operand1.intersection(operand2)
class RSSFeedContentQuery(ContentQuery):
grok.name('rss-feed')
def __call__(self):
self.total_hits = 0
feed_data = self._parse_feed()
self.total_hits = len(feed_data)
return feed_data
@property
def rss_feed(self):
return self.context.rss_feed
def _parse_feed(self):
if not self.rss_feed:
return []
items = []
try:
content = self._get_feed(self.rss_feed.url, self.rss_feed.timeout)
xml = lxml.etree.fromstring(content)
except (requests.exceptions.RequestException,
lxml.etree.XMLSyntaxError) as e:
log.debug('Could not fetch feed {}: {}'.format(
self.rss_feed.url, e))
return []
for item in xml.xpath('/rss/channel/item'):
link = zeit.content.cp.blocks.rss.RSSLink(item, self.rss_feed)
items.append(link)
return items
def _get_feed(self, url, timeout):
return requests.get(url, timeout=timeout).content
class BiWeekly(SameWeekdayBase):
"""Recurring biweekly on the same weekday."""
grok.name('biweekly')
weight = 11
title = _('every other week, same weekday (e. g. each second Friday)')
interval = TWO_WEEKS
def _get_start_date(self):
candiate = next_date_of_same_weekday(self.context, self.interval_start)
# We have to compare the naive datetimes as otherwise the DST
# difference might be computed into the difference of the two dates:
naive_candiate = self.combine_with_time_of_context(
candiate).replace(tzinfo=None)
naive_context = self.context.replace(tzinfo=None)
interval = (naive_candiate - naive_context).days
assert interval % 7 == 0, \
'Interval has {} days. This is {} weeks and {} days!'.format(
interval, interval / 7, interval % 7)
if interval % 14 != 0:
# odd number of weeks
candiate = next_date_of_same_weekday(
self.context, self.interval_start + ONE_WEEK)
return candiate
@property
def info(self):
return _('${weekday} every other week',
mapping={'weekday': self._weekday})
class BreadcrumbContentProvider(
grok.MultiAdapter, zope.contentprovider.provider.ContentProviderBase):
"""Content provider rendering the breadcrumbs."""
grok.adapter(zope.interface.Interface,
icemac.addressbook.browser.interfaces.IAddressBookLayer,
zope.interface.Interface)
grok.provides(zope.contentprovider.interfaces.IContentProvider)
grok.name('breadcrumbs')
def render(self):
return '\n'.join(self.rendered_breadcrumbs)
@property
def rendered_breadcrumbs(self):
for bc in reversed(list(self.reversed_breadcrumbs)):
yield bc.render()
@property
def reversed_breadcrumbs(self):
bc = self.get_breadcrumb(self.__parent__)
parent = bc.parent
while parent is not None:
if bc.show:
yield bc
bc = self.get_breadcrumb(parent)
parent = bc.parent
assert not bc.show, 'Found a root breadcrumb with show = True'
def get_breadcrumb(self, context):
return zope.component.getMultiAdapter((context, self.request),
IBreadcrumb)
class Yearly(RecurringDateTime):
"""Recurring on the same date each year."""
grok.name('yearly')
weight = 100
title = _('yearly (e. g. 24th of December)')
def compute(self):
if self.context > self.interval_end:
return # no need to compute: there will be no results
date = self.context
index = 0
# Find first date after interval_start:
while date < self.interval_start:
index += 1
date = add_years(self.context, index)
# Yield dates in the interval:
while date < self.interval_end:
yield date
index += 1
date = add_years(self.context, index)
@property
def info(self):
return _('${date} every year',
mapping={'date': self.context.strftime('%d.%m.')})
class PreDeployHookOpenVZ(GlobalUtility):
implements(IPreDeployHook)
name('pre-deploy-openvz')
@defer.inlineCallbacks
def execute(self, context, *args, **kw):
@db.ro_transact
def check_backend(context):
return context.__parent__.backend != 'openvz'
if (yield check_backend(context)):
return
cmd = args[0]
vm_parameters = args[1]
ctid = yield get_current_ctid()
if ctid is not None:
log.msg('Deploying %s to %s: hinting CTID (%s)' %
(context, context.__parent__, ctid),
system='deploy-hook-openvz')
vm_parameters.update({'ctid': ctid + 1})
else:
self._action_log(
cmd,
'Information about current global CTID is unavailable yet, '
'will let it use HN-local value instead',
system='deploy-hook-openvz')
class CommonMetadata(Converter):
interface = zeit.cms.content.interfaces.ICommonMetadata
# Sort ICommonMetadata first, so others can override its results
grok.name('AAA_' + interface.__name__)
entity_types = {
# BBB map zeit.intrafind entity_type to retresco.
'Person': 'person',
'Location': 'location',
'Organization': 'organisation',
'free': 'keyword',
}
entity_types.update({x: x for x in zeit.retresco.interfaces.ENTITY_TYPES})
def __call__(self):
section = None
if self.context.ressort:
section = u'/' + self.context.ressort
if self.context.sub_ressort:
section += u'/' + self.context.sub_ressort
result = {
'title':
self.context.title,
'teaser':
self.context.teaserText or self.context.title,
# The following (top-level keys) are not strictly required,
# but are used by TMS UI (for display and filtering).
'supertitle':
self.context.supertitle,
'section':
section,
'author':
u', '.join(
[x.target.display_name for x in self.context.authorships]
or [x for x in self.context.authors if x])
}
for typ in zeit.retresco.interfaces.ENTITY_TYPES:
result['rtr_{}s'.format(typ)] = []
for kw in self.context.keywords:
key = 'rtr_{}s'.format(
self.entity_types.get(kw.entity_type, 'keyword'))
result[key].append(kw.label)
result['payload'] = {}
result['payload']['head'] = {
'authors': [x.target.uniqueId for x in self.context.authorships],
}
result['payload']['body'] = {
'supertitle': self.context.supertitle,
'title': self.context.title,
'subtitle': self.context.subtitle,
'byline': self.context.byline,
}
result['payload']['teaser'] = {
'supertitle': self.context.teaserSupertitle,
'title': self.context.teaserTitle,
'text': self.context.teaserText,
}
return result
class OpenVzConsoleView(ConsoleView):
context(IOpenVzConsole)
name('webterm')
@property
def terminal_protocol(self):
return OpenVzTerminalProtocol(self.context)
class TtyConsoleView(ConsoleView):
context(ITtyConsole)
name('webterm')
@property
def terminal_protocol(self):
return TtyTerminalProtocol(self.context)
class KeywordUnion(KeywordOperator):
"""Union keywords."""
grok.name('union')
def __call__(self, operand2):
return self.operand1.union(operand2)
class Message(zeit.push.message.Message):
grok.name('facebook')
@property
def text(self):
text = self.config.get('override_text')
if not text: # BBB
self.get_text_from = 'long_text'
text = super(Message, self).text
return text
@property
def url(self):
return self.add_query_params(
super().url,
wt_zmc='sm.int.zonaudev.facebook.ref.zeitde.redpost.link.x',
utm_medium='sm',
utm_source='facebook_zonaudev_int',
utm_campaign='ref',
utm_content='zeitde_redpost_link_x',
)
@property
def log_message_details(self):
return 'Account %s' % self.config.get('account', '-')
def _disable_message_config(self):
push = zeit.push.interfaces.IPushMessages(self.context)
if self.config.get('breaking_news'):
push.set(self.config, enabled=False, breaking_news=False)
else:
push.set(self.config, enabled=False)
class KeywordDifference(KeywordOperator):
"""Difference keywords."""
grok.name('difference')
def __call__(self, operand2):
return self.operand1.difference(operand2)
class Container(zeit.edit.container.TypeOnAttributeContainer,
grok.MultiAdapter):
grok.provides(IContainer)
grok.adapts(IContainer, gocept.lxml.interfaces.IObjectified)
type = 'container'
grok.name(type)
class PickleConsumer(Consumer):
grok.name("my.picklequeue")
connection_id = "test.connection"
queue = "my.picklequeue"
marker = IPickleMessage
class ForbiddenPage(Page):
name('')
context(exceptions.HTTPForbidden)
require('zope.Public')
def render(self):
return _(u"This page is protected and you don't have the credentials.")
class Volume(Converter):
"""This adapter is for indexing actual IVolume objects. Since ICMSContent
objects can be adapted to IVolume (finding the associated volume object),
we explicitly restrict this here (which is different from the baseclass).
"""
interface = zeit.content.volume.interfaces.IVolume
grok.name(interface.__name__)
def __new__(cls, context):
if not cls.interface.providedBy(context):
return None
if sys.version_info < (3, ):
instance = super(Converter, cls).__new__(cls, None)
else:
instance = super(Converter, cls).__new__(cls)
instance.context = context
instance.content = context
return instance
def __call__(self):
result = {
'title': self.context.teaserText or 'Ausgabe',
'teaser': self.context.teaserText or 'Ausgabe',
}
covers = [{
'id': x.get('id'),
'product_id': x.get('product_id'),
'href': x.get('href')
} for x in self.context.xml.xpath('//covers/cover')]
if covers:
result['payload'] = {'head': {'covers': covers}}
return result
class Push(Converter):
"""We have to index IPushMessages.message_config explicitly, since the DAV
property is serialized as xmlpickle, which is not queryable. Additionally,
we transpose its structure from
{type: typ1, key1: val1, ...}, {type: typ2, ...}, ...] to
{
typ1: {key1: [val1, val2, ...], ...},
typ2: {key1: [val3, ...], ...},
}
to create something that can be queried.
"""
interface = zeit.push.interfaces.IPushMessages
grok.name(interface.__name__)
def __call__(self):
if not self.context.message_config:
return {}
result = {}
for config in self.context.message_config:
typ = config.pop('type', None)
if not typ:
continue
config.pop('enabled', None)
data = result.setdefault(typ, {})
for key, value in config.items():
data.setdefault(key, []).append(value)
return {'payload': {'push': result}}
class Image(Converter):
interface = zeit.content.image.interfaces.IImageMetadata
grok.name(interface.__name__)
def __new__(cls, context):
if u'/news/' in context.uniqueId:
# skip zeit.newsimport images. Unfortunately, image(groups) have no
# ressort or product-id with which we could filter this.
return None
return super(Image, cls).__new__(cls, context)
def __call__(self):
title = self.context.title or self.content.__name__
return {
# Required fields, so make sure to always index (for zeit.find).
'title': title,
'teaser': self.context.caption or title,
'payload': {
'body': {
'title': title,
'text': self.context.caption or title,
}
}
}
class TestConsumer(Consumer):
grok.name('my.queue')
connection_id = 'test.connection'
queue = 'my.queue'
marker = ITestMessage
class HtmlEntryPoint(component.MultiAdapter):
""" generate a index html. This html site will than
load extjs framework with css and run the
application.
"""
component.name('index')
component.adapts(IApplicationContext, IRequest)
tmpl = loader.load('index.html')
def __init__(self, context, request):
self.context = context
self.request = request
def __call__(self):
resources = fanstatic.get_needed()
stream = self.tmpl.generate(resources=Markup(resources.render()),
title=self.context.title,
launcher=Markup(self.launcher()))
self.request.response.mimetype = 'text/html'
self.request.response.write(stream.render('html', doctype='html'))
def launcher(self):
""" create a js script that launch the application.
"""
js = """
Ext.onReady(function() {
Ext.application('%s');
});
"""
return js % self.context.application
class TestProducer(Producer):
grok.name('my.queue')
connection_id = 'test.connection'
queue = 'my.queue'
serializer = 'text/plain'
class RequestCredentialsPlugin(component.GlobalUtility):
""" Fetch credentials from HTTP headers.
"""
component.name('request_credentials')
def extractCredentials(self, request):
""" fetch remote user in the http headers
and create credentials with it.
"""
session = ISession(request)
cred = dict(login=request.params.get(FORM_LOGIN, None),
password=request.params.get(FORM_PASSWORD, None))
if None in cred.values():
if SESSION_CREDENTIALS in session:
return session[SESSION_CREDENTIALS]
else:
return None
session[SESSION_CREDENTIALS] = cred
return cred
def challenge(self, request):
return False
def logout(self, request):
session = ISession(request)
re = SESSION_CREDENTIALS in session
del session[SESSION_CREDENTIALS]
return re
class BioReference(zeit.cms.content.reference.Reference):
grok.implements(zeit.content.author.interfaces.IAuthorBioReference)
grok.provides(zeit.content.author.interfaces.IAuthorBioReference)
grok.name('authorbio')
biography = zeit.cms.content.property.ObjectPathProperty('.biography')
class Reference(zeit.cms.content.reference.Reference):
grok.implements(zeit.content.author.interfaces.IAuthorReference)
grok.provides(zeit.content.author.interfaces.IAuthorReference)
grok.name('author')
location = zeit.cms.content.property.ObjectPathProperty('.location')
class BasicAuthLogoutView(LogoutView):
context(OmsRoot)
name('basicauthlogout')
require('oms.nothing')
def render_GET(self, request):
super(BasicAuthLogoutView, self).render_GET(request)
raise Unauthorized()
"""
This should fail:
"""
import grokcore.component as grok
grok.name('viewname')
