class FormQuestionnaireSSViewlet(mars.viewlet.SimpleViewlet,
QuestionnaireCSSViewlet):
"""css viewlet"""
grok.name('questionnaire.css')
grok.context(zope.interface.Interface)
mars.viewlet.view(IQuestionnairePage)
mars.viewlet.manager(skin.CSSManager)
class MinimalAppIndex(grok.View):
grok.name("index")
grok.context(Interface)
grok.require('zope.View')
def render(self):
return "Hallo Welt"
class PersonWizard(mars.view.PageletView, Wizard):
grok.name('wizard')
grok.context(IFolder)
form.extends(Wizard)
title = u'Wizard Demo - Person Demographics'
sessionKey = 'z3c.formdemo.wizard.person'
steps = [('personalInfo', browser.PersonalInfoStep),
('address', browser.AddressStep), ('father', browser.FatherStep),
('mother', browser.MotherStep),
('employer', browser.EmployerStep)]
def finish(self):
self.request.response.redirect('summary')
def getContent(self):
session = ISession(self.request)[self.sessionKey]
obj = session.get('content')
if obj is None:
obj = session['content'] = content.Person()
return obj
@button.buttonAndHandler(u'Clear',
condition=lambda form: form.isFirstStep(),
provides=(interfaces.IBackButton, ))
def handleClear(self, action):
session = ISession(self.request)[self.sessionKey]
del session['content']
self.request.response.redirect(self.request.getURL() + '?step=' +
self.steps[0][0])
class ExternalAssetIndex(asm.mediagallery.externalasset.Index, ViewUtils):
grok.layer(ISkin)
grok.context(asm.mediagallery.interfaces.IExternalAsset)
grok.name('index')
@property
def current_url_escaped(self):
return urllib.quote_plus(self.url(self.context))
@property
def title(self):
title = self.context.title
party = self.context.__parent__.__parent__.__parent__
party_year = int(party.__name__)
category = self.context.__parent__.__parent__
category_edition = asm.cms.edition.select_edition(
category, self.request)
party_name = get_party_name(party_year, category)
if 'assemblytv' in category.__name__ or \
'seminar' in category.__name__ or \
'winter' in category.__name__:
return u"%s / %s / %s" % (title, party_name,
category_edition.title)
author = self.info.author
return u"%s by %s" % (title, author)
def update(self):
super(ExternalAssetIndex, self).update()
self.info = IMediaGalleryAdditionalInfo(self.context)
class DeleteDraft(asm.cmsui.base.ActionView):
grok.context(asm.cms.IEdition)
grok.name('delete-draft')
def update(self):
page = self.context.page
draft = self.context.parameters.replace(WORKFLOW_PUBLIC,
WORKFLOW_DRAFT)
try:
draft = page.getEdition(draft)
except KeyError:
self.flash(u"No draft version to delete.")
return
public = self.context.parameters.replace(WORKFLOW_DRAFT,
WORKFLOW_PUBLIC)
try:
public = page.getEdition(public)
except KeyError:
self.flash(u"Can not delete draft without public version.")
return
del draft.__parent__[draft.__name__]
self.flash(u'Deleted draft version.')
self.redirect(self.url(public, '@@edit'))
class UpdateWithArguments(grok.View):
grok.name('update')
grok.template('update')
def update(self, message, another):
self.message = message
self.another = another
class UserAuthenticatorPlugin(grok.GlobalUtility):
grok.name("temporary_users")
required = {'login', 'password'}
def getAccount(self, id):
catalog = queryUtility(ICatalog, name="qah.users_catalog")
if catalog is None:
return None
users = list(catalog.searchResults(uid=(id, id)))
if users:
assert len(users) == 1
return users[0]
return None
def authenticateCredentials(self, credentials):
# Empty or malformed credentials are ignored.
if not credentials or (self.required - set(credentials)):
return
account = self.getAccount(credentials['login'])
if account is not None:
token = encrypt('%(login)s:%(password)s' % credentials)
if account.token == token:
return TemporaryInfo(id=account.uid, document=account)
return None
def principalInfo(self, id):
account = self.getAccount(id)
if account is None:
return
return TemporaryInfo(id=account.uid, document=account)
class RevokeMembership(grok.View):
grok.context(User)
grok.name('revoke')
grok.require(u'gum.Edit')
def update(self):
gid = self.request.form.get('gid', None)
if not gid: return
group = grok.getApplication()['groups'][gid]
new_group = []
for uid in group.uids:
if uid != self.context.__name__:
new_group.append(uid)
group.uids = new_group
# TO-DO oh the hackery!!!
group.principal_id = self.request.principal.id
event.notify(grok.ObjectModifiedEvent(group))
# save must be called after event notification, otherwise it
# can't diff between the before and after states!
group.save()
def render(self):
# TO-DO: pass a status message to the UI
self.redirect(self.url(self.context))
class Index(grok.View):
grok.context(Transcripts)
grok.name('index')
grok.require(u'gum.View')
def site(self):
return grok.getApplication()
class MammothIndexes(grok.Indexes):
grok.context(Mammoth)
grok.name('foo_catalog')
name = index.Field()
age = index.Field()
message = index.Text()
class ExtraViewsViewlet(grok.ViewletManager):
grok.order(20)
grok.baseclass()
grok.view(Interface)
grok.name('extra-views')
grok.viewletmanager(uvcsite.browser.layout.slots.interfaces.IAboveContent)
grok.require("zope.Public")
# menu_factory = menus.ExtraViews
menu_factory = object()
def update(self):
super().update()
if not len(self.menu.viewlets) or ISimpleForm.providedBy(self.view):
self.actions = None
else:
self.actions = self.compute_actions(self.menu.viewlets)
def compute_actions(self, viewlets):
for action in viewlets:
selected = action.viewName == self.view.__name__
context_url = self.menu.view.url(self.menu.context)
url = selected and None or "%s/%s" % (context_url, action.viewName)
yield {
'id': action.__name__,
'url': url,
'title': action.title or action.__name__,
'selected': selected,
'class': (selected and 'selected ' +
self.menu.menu_class or self.menu.menu_class),
}
class UKHCookiesCredentials(CookiesCredentials):
grok.name("ukh_cookies")
gebdatefield = "gebdate"
@staticmethod
def make_cookie(login, password, gebdate):
credstr = u"%s:%s:%s" % (login, password, gebdate)
val = base64.encodestring(credstr.encode("utf-8"))
return urllib.quote(val)
def extractCredentials(self, request):
if not IHTTPRequest.providedBy(request):
return
login = request.get(self.loginfield, None)
password = request.get(self.passwordfield, None)
gebdate = request.get(self.gebdatefield, None)
cookie = request.get(self.cookie_name, None)
if login and password and gebdate:
cookie = self.make_cookie(login, password, gebdate)
request.response.setCookie(self.cookie_name, cookie, path="/")
elif cookie:
val = base64.decodestring(urllib.unquote(cookie)).decode("utf-8")
login, password, gebdate = val.split(":")
else:
return
return {"login": login, "password": password, "gebdate": gebdate}
class UserAuthenticatorPlugin(UsersManagement, grok.LocalUtility):
grok.name("users")
def authenticateCredentials(self, credentials):
USER_SESSION_KEY = "adhoc.authentication"
request = uvcsite.getRequest()
session = ISession(request)['adhoc.authentication']
authenticated = session.get(USER_SESSION_KEY)
if authenticated is None:
if not isinstance(credentials, dict):
return
account = self.getAccount(credentials["login"])
if account is None:
return None
if not account.checkPassword(
credentials["password"],
credentials.get("gebdate", '99.99.9999')):
return None
else:
authenticated = session[USER_SESSION_KEY] = dict(id=account.az)
return PrincipalInfo(**authenticated)
def getAccount(self, login):
return self.get(login)
def principalInfo(self, id):
account = self.getAccount(id)
if account is None:
return
return PrincipalInfo(id=account.az)
class SubscriptionJavaScriptViewlet(mars.viewlet.SimpleViewlet,
jsevent.JSSubscriptionsViewlet):
"""subscriptions viewlet"""
grok.name('subscriptions')
grok.context(zope.interface.Interface)
mars.viewlet.manager(JavaScriptManager)
mars.viewlet.view(IHaveJSSubscriptions)
class PageBase(grok.View):
grok.context(asm.cms.interfaces.IPage)
grok.name('base')
def render(self):
return self.url(self.context) + '/'
class UserIndex(grok.View):
grok.context(User)
grok.name('index')
grok.require(u'gum.View')
@property
def transcripts_by_dn(self):
url = self.url(grok.getApplication()['transcripts'], 'by-dn')
url += '?'
url += urlencode([('dn', self.context.dn)])
return url
def adjusted_core_fields(self):
"List of core fields adjusted for a more user friendly display"
# adjusted means 'officeLocation' and 'userPassword'
fields = core_user_fields()
fields = fields.omit(
'roomNumber',
'street',
'userPassword',
)
ol_field = copy.copy(IUser['officeLocation'])
ol_field.__name__ = 'officeLocationClean'
fields += FormFields(ol_field)
return fields
def recent_transcripts(self):
transcripts = self.context.transcripts()
# Catalog ResultSet is lazy, and does not support slicing
transcripts = [x for x in transcripts]
return transcripts[:5]
def is_list(self, field):
return schema.interfaces.IList.providedBy(field)
class EditionBase(grok.View):
grok.name('base')
grok.context(asm.cms.interfaces.IEdition)
def render(self):
return self.url(self.context.page) + '/'
class WorkflowLabels(grok.GlobalUtility):
zope.interface.implements(asm.cms.interfaces.IEditionLabels)
grok.name('workflow')
def lookup(self, tag):
return WORKFLOW_LABELS[tag]
class Edit(asm.cmsui.form.EditionEditForm):
grok.layer(asm.cmsui.interfaces.ICMSSkin)
grok.name('edit')
main_fields = grok.AutoFields(asm.cms.redirect.Redirect).select(
'title', 'target_url')
class CreateDraft(asm.cmsui.base.ActionView):
"""Create (or update) a draft by copying the current state of the published
edition to the draft object.
This action view can be applied either on the draft or the public copy with
the same result.
"""
grok.context(asm.cms.IEdition)
grok.name('create-draft')
def update(self):
page = self.context.page
public = self.context.parameters.replace(WORKFLOW_DRAFT,
WORKFLOW_PUBLIC)
try:
public = page.getEdition(public)
except KeyError:
self.flash(u"Cannot revert because no public edition exists.")
return
draft = public.parameters.replace(WORKFLOW_PUBLIC, WORKFLOW_DRAFT)
draft = page.getEdition(draft, create=True)
draft.copyFrom(public)
self.flash(u"Copied data from public version to draft.")
self.redirect(self.url(draft, '@@edit'))
class DemosceneTV(grok.GlobalUtility):
grok.provides(asm.mediagallery.interfaces.IEmbeddableContentHostingService)
grok.name('demoscenetv')
EMBED_TEMPLATE = """
<embed src="http://www.demoscene.tv/mediaplayer.swf?id=%(id_file)s_%(id_prod)s_%(id_app)s" width="%(width)s" height="%(height)s" allowfullscreen="true" type="application/x-shockwave-flash" pluginspage="http://www.macromedia.com/go/getflashplayer" />""" # NOQA
CONTROLS_HEIGHT = 20.0
ASPECT_RATIO = 16.0 / 9.0
DEFAULT_WIDTH = 512
def _get_vars(self, media_id):
return dict(
map(lambda x: (x[0], x[1][0]),
cgi.parse_qs(media_id).items()))
@no_call_on_empty
def link_code(self, media_id):
media_vars = self._get_vars(media_id)
return ('<a href="http://demoscene.tv/prod.php?id_prod=%s">'
'DTV</a>') % media_vars['id_prod']
def embed_code(self,
request,
media_id,
max_width=DEFAULT_WIDTH,
max_height=None):
media_vars = self._get_vars(media_id)
width = int(media_vars['width'])
height = int(media_vars['height'])
aspect = float(width) / height
new_width, new_height = calculate_embed_size(aspect, 0, max_width)
media_vars['width'] = new_width
media_vars['height'] = new_height
return self.EMBED_TEMPLATE % media_vars
class MyTab(TabItem):
grok.name('delete')
urlEndings = [
'delete',
]
viewURL = 'delete'
class YoutubeHosted(grok.GlobalUtility):
grok.provides(asm.mediagallery.interfaces.IEmbeddableContentHostingService)
grok.name('youtube')
YOUTUBE_PARAMETERS = "&hl=en_US&fs=1&enablejsapi=1&showinfo=0&modestbranding=1&autoplay=1&playerapiid=ytplayerembed&origin=%(origin)s" # NOQA
EMBED_TEMPLATE = '<iframe id="ytplayerembed" class="youtube-player" width="%(width)d" height="%(height)d" src="http://www.youtube.com/embed/%(id)s?%(params)s" style="border: 0">\n</iframe>' # NOQA
CONTROLS_HEIGHT = 25.0
ASPECT_RATIO = 16.0 / 9.0
DEFAULT_WIDTH = 640
@no_call_on_empty
def link_code(self, media_id):
return ('<a href="http://www.youtube.com/watch?v=%s">'
'YouTube</a>') % media_id.strip()
def embed_code(self,
request,
media_id,
max_width=DEFAULT_WIDTH,
max_height=None):
width, height = calculate_embed_size(self.ASPECT_RATIO,
self.CONTROLS_HEIGHT, max_width)
origin = urlparse.urlparse(request.getApplicationURL()).netloc
parameters = self.YOUTUBE_PARAMETERS % {'origin': origin}
return self.EMBED_TEMPLATE % {
'id': media_id.strip(),
'width': width,
'height': height,
'params': parameters,
}
class PersonSummary(mars.form.FormView, layout.FormLayoutSupport,
form.DisplayForm):
grok.name('summary')
grok.context(zope.interface.Interface)
fields = field.Fields(
interfaces.IPersonalInfo).select(*browser.infoSelection)
def getContent(self):
session = ISession(self.request)[PersonWizard.sessionKey]
return session.get('content')
def update(self):
content = self.getContent()
self.father = form.DisplayForm(content.father, self.request)
self.father.fields = field.Fields(
interfaces.IPersonalInfo).select(*browser.infoSelection)
self.father.update()
self.mother = form.DisplayForm(content.mother, self.request)
self.mother.fields = field.Fields(
interfaces.IPersonalInfo).select(*browser.infoSelection)
self.mother.update()
self.employer = form.DisplayForm(content.employer, self.request)
self.employer.fields = field.Fields(interfaces.IEmployerInfo).select(
'name', 'street', 'city', 'zip')
self.employer.update()
super(PersonSummary, self).update()
class PluginOverview(uvcsite.Form):
grok.context(IPlugin)
grok.name('index')
grok.require('grok.ManageApplications')
prefix = ""
fields = uvcsite.Fields()
needs_fontawesome = True
@property
def actions(self):
return self.context.actions
def updateForm(self):
form, action, result = self.updateActions()
if action is not None:
self.title = action.title
if result is not FAILURE:
assert isinstance(result, Result)
if result.type is ResultTypes.MESSAGE:
self.flash(result.value)
if result.redirect:
return self.redirect(self.url(self.context))
else:
rendering = getMultiAdapter(
(self.context, self.request, result),
name=result.type.value)
self.result = rendering()
self.updateWidgets()
def update(self):
self.title = None
self.result = None
self.status = self.context.status
self.is_installed = self.status.state == States.INSTALLED
class Homepage(asm.cmsui.retail.Pagelet):
grok.context(asm.cms.homepage.Homepage)
grok.layer(ISkin)
grok.name('index')
def news(self, tag):
if 'news' not in self.context.page:
raise StopIteration()
news_edition = asm.cms.edition.select_edition(
self.context.page['news'], self.request)
for item in news_edition.list():
edition = asm.cms.edition.select_edition(
item, self.request)
if isinstance(edition, asm.cms.edition.NullEdition):
continue
if not edition.has_tag(tag):
continue
result = dict(edition=edition,
news=asm.cms.news.INewsFields(edition))
if result['news'].image:
result['teaser_url'] = self.url(edition.page['teaser-image'])
else:
result['teaser_url'] = ''
yield result
def featured(self):
return sorted(self.news('featured'),
key=lambda x: x['edition'].modified,
reverse=True)
def frontpage(self):
return list(sorted(self.news('frontpage'),
key=lambda x: x['edition'].modified,
reverse=True))[:12]
class Menu(collections.abc.Iterable):
grok.name('base menu')
grok.context(Interface)
grok.provides(IMenu)
grok.baseclass()
def __init__(self, context, request, view):
self.context = context
self.request = request
self.view = view
def available(self):
return True
def __iter__(self):
entries = grokcore.component.sort_components((
e for name, e in getAdapters(
(self, self.context, self.request, self.view), IMenuEntry)))
for e in entries:
e.__parent__ = self
if zope.security.canAccess(e, 'available') and e.available():
yield e
def update(self):
self.entries = list(iter(self))
class QuestionnaireAddForm(mars.form.FormView, layout.AddFormLayoutSupport,
group.GroupForm, form.AddForm):
"""Questionnaire add form"""
grok.name('addQuestionnaire')
grok.context(IFolder)
zope.interface.implements(IQuestionnairePage)
label = u'Zope Developer Questionnaire'
fields = field.Fields(IQuestionnaire).select('name', 'age')
groups = (DevelopmentExperienceGroup, ContributorExperienceGroup)
def create(self, data):
return Questionnaire(**data)
def add(self, object):
count = 0
while 'questionnaire-%i' % count in self.context:
count += 1
self._name = 'questionnaire-%i' % count
self.context[self._name] = object
return object
def nextURL(self):
url = absoluteURL(self.context, self.request)
return url + '/questionnaireResults'
class BoolHiddenDisplayWidget(CheckBoxDisplayWidget):
grok.name('hiddendisplay')
def checkValue(self, value):
if value in ('No', ):
return False
return True
class Configure(uvcsite.browser.Form):
grok.context(IPluginConfiguration)
grok.name("index")
grok.require("uvc.ManageCoUsers")
ignoreContent = False
ignoreRequest = False
dataManager = DictDataManager
@CachedProperty
def factory(self):
return getUtility(IConfigurablePlugin, name=self.context.__name__)
@CachedProperty
def label(self):
return self.factory.title
@CachedProperty
def fields(self):
return self.factory.configuration_fields
@action(u"Speichern")
def save_configuration(self):
data, errors = self.extractData()
if errors:
self.flash("Es ist ein Fehler aufgetreten.")
return FAILURE
item = self.getContent()
item.update(data)
self.flash("Ihre Einstellungen wurden gespeichert.")
return SUCCESS
jsonresponse = dict()
graph_xml = form.request.form['data']
try:
graph = SetobjectGraph(form.request, graph_xml)
graph.save()
jsonresponse['result'] = 'OK'
except SetobjectGraphException, ex:
jsonresponse['error'] = {'title': 'Save failed',
'message': ex.reason,
'data_node_id': ex.setobjectid}
form.jsonresponse = jsonresponse
grok.name('index')
grok.context(IGenericSet)
grok.title(_(u"Edit data"))
grok.require('dolmen.content.View')
actions = Actions(SaveAction('Save'),)
def __call__(self):
if self.request.headers.get('X-Requested-With') == 'XMLHttpRequest':
self.updateActions()
self.response.setHeader('Content-Type', 'application/json')
return json.dumps(self.jsonresponse)
else:
return super(EditData, self).__call__()
@property
