class Home(grok.MultiAdapter):
grok.adapts(Cave, Fireplace)
grok.implements(IHome)
def __init__(self, cave, fireplace):
self.cave = cave
self.fireplace = fireplace
class OptionalChoiceFieldWidget(choice.ChoiceFieldWidget):
grok.adapts(OptionalChoiceField, Interface, Interface)
def update(self):
super(OptionalChoiceFieldWidget, self).update()
optchoice.need()
@property
def selectValue(self):
value = self.inputValue()
if isinstance(value, list):
return value[0]
return value
@property
def textValue(self):
value = self.inputValue()
if isinstance(value, list):
value = value[1]
try:
self.choices().getTermByToken(value)
return ''
except:
return value
def valueToUnicode(self, value):
try:
term = self.choices().getTerm(value)
return term.token
except LookupError:
return value
class RadioFieldWidget(zeam.form.ztk.widgets.choice.RadioFieldWidget):
grok.adapts(zeam.form.ztk.widgets.choice.ChoiceField,
zope.interface.Interface, zope.interface.Interface,
ISiguvTheme)
def htmlClass(self):
return "form-check-input"
class Home2(grok.MultiAdapter):
grok.adapts(Cave, Fireplace)
grok.name('home2')
def __init__(self, cave, fireplace):
self.cave = cave
self.fireplace = fireplace
class AdHocDocumentInfo(grok.MultiAdapter):
grok.adapts(IPrincipal, IHTTPRequest)
grok.implements(IAdHocDocumentInfo)
grok.baseclass()
def __init__(self, principal, request):
self.principal = principal
self.request = request
def getProductFolder(self):
base = grok.getSite()['dokumente']
folder_name = time.strftime('%Y_%m_%d', time.localtime())
if not folder_name in base.keys():
base[folder_name] = AdHocProductFolder()
return base[folder_name]
def getAddLink(self, id, docart):
obj = self.getObject(id)
if obj:
return grok.url(self.request, obj)
datefolder = self.getProductFolder()
data = {'form.field.docid': id}
addlink = "@@%s" % (
docart.replace(' ', '_'))
return grok.url(self.request, datefolder, addlink, data=data)
def getObject(self, id):
util = getUtility(IAdHocIdReference)
return util.queryObject(id)
class HomeFolderUrl_deprecated(grok.MultiAdapter):
grok.adapts(IPrincipal, IBrowserRequest)
def __init__(self, context, request):
adapter = IGetHomeFolderUrl(request)
self.getURL = adapter.getURL
self.getAddURL = adapter.getAddURL
class MultiChoiceFieldWidget(
zeam.form.ztk.widgets.collection.MultiChoiceFieldWidget):
grok.adapts(zeam.form.ztk.widgets.collection.SetField,
zeam.form.ztk.widgets.collection.ChoiceField,
zope.interface.Interface, ISiguvTheme)
def htmlClass(self):
return "form-check-input"
class HiddenTextAdapter(grok.MultiAdapter):
''' Define an adapter for our schema field which selects our hidden text widget
'''
grok.adapts(HiddenText, IBrowserRequest)
grok.implements(IInputWidget)
def __new__(self, field, request):
return HiddenTextWidget(field, request)
class CalculatorContentProvider(grok.MultiAdapter)
grok.adapts(Calculator, IBrowserRequest, IBrowserView)
grok.implements(IContentProvider)
def __init__(self, context, request, view):
self.context = context
self.request = request
self.view = view
class ActionWidget(ActionWidget):
grok.adapts(interfaces.IAction, interfaces.IFieldExtractionValueSetting,
ITBSkin)
icon = None
def htmlClass(self):
return 'btn ' + ' '.join(self.defaultHtmlClass)
class Home3(grok.MultiAdapter):
grok.adapts(Cave, Fireplace)
grok.implements(IHome, IFireplace)
grok.provides(IHome)
grok.name('home3')
def __init__(self, cave, fireplace):
self.cave = cave
self.fireplace = fireplace
class SingleAdapter(grok.Adapter):
grok.context(Calculator)
grok.adapts(Calculator) # generally allowed, but not in this case, because there's already grok.context
grok.implements(ISomething) # if this is not specified, app breaks
grok.provides(ISomething) # if adapter implements more than one interface
grok.name('') # this is actually the default
def something(self):
"""self.context is automatically provided"""
return self.context.foo
class PluginConfigurationNamespace(grok.MultiAdapter):
grok.name('plugins')
grok.provides(ITraversable)
grok.adapts(Interface, Interface)
def __init__(self, context, request):
self.context = context
self.request = request
def traverse(self, name, ignore):
return get_plugin_configuration(request=self.request, name=name)
class UVCSitePrincipalFactory(factories.AuthenticatedPrincipalFactory,
grok.MultiAdapter):
grok.adapts(interfaces.IPrincipalInfo, IDefaultBrowserLayer)
def __call__(self, authentication):
principal = Principal(authentication.prefix + self.info.id,
self.info.description)
grok.notify(
interfaces.AuthenticatedPrincipalCreated(authentication, principal,
self.info, self.request))
return principal
class RedirectAbsoluteUrl(grok.MultiAdapter):
grok.adapts(asm.cms.interfaces.IRedirect,
asm.cmsui.interfaces.IRetailBaseSkin)
grok.implements(zope.traversing.browser.interfaces.IAbsoluteURL)
def __init__(self, context, request):
self.context = context
self.request = request
def __call__(self):
return self.context.target_url
class plain(grok.MultiAdapter):
grok.name('text/plain')
grok.provides(zope.interface.Interface)
grok.adapts(IPlugin, IDefaultBrowserLayer, Result)
def __init__(self, plugin, request, result):
self.plugin = plugin
self.request = request
self.result = result
def __call__(self):
return u'<pre>%s</pre>' % self.result.value
class CustomBatch(BatchProvider, grok.MultiAdapter):
grok.adapts(Interface, IUVCSkin, ITable)
grok.name('batch')
def renderBatchLink(self, batch, cssClass=None):
args = self.getQueryStringArgs()
args[self.table.prefix + '-batchStart'] = batch.start
args[self.table.prefix + '-batchSize'] = batch.size
query = urlencode(sorted(args.items()))
tableURL = absoluteURL(self.table, self.request)
idx = batch.index + 1
css = ' class="%s"' % cssClass
cssClass = cssClass and css or u''
return '<li %s><a href="%s?%s"%s>%s</a><li>' % (
cssClass, tableURL, query, cssClass, idx)
def render(self):
self.update()
res = []
append = res.append
idx = 0
lastIdx = len(self.batchItems)
for batch in self.batchItems:
idx += 1
# build css class
cssClasses = []
if batch and batch == self.batch:
cssClasses.append('active')
if idx == 1:
cssClasses.append('first')
if idx == lastIdx:
cssClasses.append('last')
if cssClasses:
css = ' '.join(cssClasses)
else:
css = None
# render spaces
if batch is None:
append(self.batchSpacer)
elif idx == 1:
# render first
append(self.renderBatchLink(batch, css))
elif batch == self.batch:
# render current
append(self.renderBatchLink(batch, css))
elif idx == lastIdx:
# render last
append(self.renderBatchLink(batch, css))
else:
append(self.renderBatchLink(batch))
return u'<ul class="pagination">%s</ul>' % (''.join(res))
class JSON(grok.MultiAdapter):
grok.name('application/json')
grok.provides(zope.interface.Interface)
grok.adapts(IPlugin, IDefaultBrowserLayer, Result)
def __init__(self, plugin, request, result):
self.plugin = plugin
self.request = request
self.result = result
def __call__(self):
return u'<pre>%s</pre>' % json.dumps(
self.result.value, indent=4, sort_keys=True)
class Service(grok.MultiAdapter):
grok.baseclass()
grok.adapts(IApplication, IHTTPRequest)
grok.implements(IPublishTraverse, IService)
grok.provides(IService)
layer = None
def __init__(self, context, request):
self.context = context
self.request = request
def publishTraverse(self, request, name):
raise NotImplementedError("implement me")
class ProductFolderValues(Values):
"""This Adapter returns IContent Objects
form child folders
"""
grok.adapts(uvcsite.content.interfaces.IProductFolder, None, Index)
@property
def values(self):
results = []
interaction = self.request.interaction
for value in self.context.values():
if interaction.checkPermission('uvc.ViewContent', value):
results.append(value)
return results
class OptionalChoiceWidgetExtractor(WidgetExtractor):
grok.adapts(OptionalChoiceField, Interface, Interface)
def extract(self):
value, error = super(OptionalChoiceWidgetExtractor, self).extract()
value, input = value
if input:
return (input, error)
if value is not NO_VALUE:
choices = self.component.getChoices(self.form)
try:
value = choices.getTermByToken(value).value
except LookupError:
return (None, u'Invalid value')
return (value, error)
class ENMSHomeFolderTraverser(grok.MultiAdapter):
grok.context(IHomeFolder)
grok.name('enms')
grok.provides(ITraversable)
grok.adapts(IHomeFolder, Interface)
def __init__(self, context, request):
self.context = context
self.request = request
def traverse(self, name, ignore):
lister = ENMSLister(self.context, 'enms')
if not name:
return lister
return lister.get(name)
class HomeFolderValues(Values):
"""This Adapter returns IContent Objects form child folders.
"""
grok.adapts(IHomeFolder, None, Index)
@property
def values(self):
results = []
interaction = self.request.interaction
for productfolder in self.context.values():
if interaction.checkPermission('uvc.ViewContent', productfolder):
if not productfolder.__name__.startswith('__'):
for obj in productfolder.values():
if interaction.checkPermission('uvc.ViewContent', obj):
results.append(obj)
return results
class FileWidgetExtractor(WidgetExtractor):
"""A value extractor for a file widget (including image)
"""
grok.adapts(FilesSchemaField, interfaces.IFormData, Interface)
def extract(self):
content = self.form.getContentData().getContent()
existing = getattr(content, self.component._field.getName())
value = self.request.form.get(self.identifier + '[]') or NO_VALUE
if not isinstance(value, list):
if value is NO_VALUE:
value = []
else:
value = [value]
existing.extend(
[NamedFile(x.read(), filename=x.filename) for x in value])
return (existing, None)
class TemporaryInfoFactory(grok.MultiAdapter):
grok.adapts(TemporaryInfo, IRequest)
def __init__(self, info, request):
self.info = info
self.request = request
def __call__(self, authentication):
principal = TemporaryPrincipal(authentication.prefix + self.info.id,
self.info.title,
self.info.description,
document=self.info.document)
grok.notify(
interfaces.AuthenticatedPrincipalCreated(authentication, principal,
self.info, self.request))
applySkin(self.request, ITemporarySkin)
return principal
class AdHocPrincipalFactory(factories.AuthenticatedPrincipalFactory,
grok.MultiAdapter):
grok.adapts(interfaces.IPrincipalInfo, ITBSkinLayer)
#grok.baseclass()
def __call__(self, authentication):
principal = super(AdHocPrincipalFactory, self).__call__(authentication)
#principal = AdHocPrincipal(
# authentication.prefix + self.info.id, self.info.description
#)
#grok.notify(
# interfaces.AuthenticatedPrincipalCreated(
# authentication, principal, self.info, self.request
# )
#)
alsoProvides(self.request, IUKHAdHocLayer)
return principal
class ServicesNamespace(grok.MultiAdapter):
grok.name('services')
grok.provides(ITraversable)
grok.adapts(uvcsite.IUVCSite, IHTTPRequest)
def __init__(self, context, request):
self.context = context
self.request = request
def traverse(self, name, ignore):
if not name:
raise NotImplementedError('Please specify a service.')
service = getMultiAdapter((self.context, self.request),
IService,
name=name)
if service.layer is not None:
applySkin(self.request, service.layer)
return LocationProxy(service, self.context, "++services++%s" % name)
class ServicesNamespace(grok.MultiAdapter):
grok.name("services")
grok.provides(ITraversable)
grok.adapts(IApplication, IHTTPRequest)
def __init__(self, context, request):
self.context = context
self.request = request
def traverse(self, name, ignore):
if not name:
raise NotImplementedError("Please specify a service.")
service = queryMultiAdapter((self.context, self.request), IService, name=name)
if service is None:
raise LookupError("Unknown service : %s" % name)
else:
if service.layer is not None:
applySkin(self.request, service.layer)
return LocationProxy(service, self.context, "++services++%s" % name)
class FilesWidget(SchemaFieldWidget):
grok.adapts(FilesSchemaField, interfaces.IFormData, Interface)
grok.template(str(INPUT))
def prepareContentValue(self, value):
if value is NO_VALUE or value is None:
return {self.identifier: False}
return {self.identifier: True}
def update(self):
filer_css.need()
filer_js.need()
#if not self.form.ignoreContent:
## raise NotImplementedError("Files can't be represented.")
SchemaFieldWidget.update(self)
def getFiles(self):
import json
content = self.form.getContentData().getContent()
if getattr(content, self.component._field.getName(), None):
rc = [{
'url':
'%s/++download++%s' %
(grok.url(self.request, content), fileobj.filename),
'name':
fileobj.filename,
'size':
fileobj.size,
'type':
fileobj.contentType
} for fileobj in self.component._field.get(content)]
else:
rc = []
print json.dumps(rc)
return json.dumps(rc)
class ProductRegistration(grok.MultiAdapter):
grok.adapts(IPrincipal, IHTTPRequest)
grok.baseclass()
icon = None
def __init__(self, principal, request):
self.principal = principal
self.request = request
self.title = grok.title.bind().get(self)
self.name = grok.name.bind().get(self)
self.description = grok.description.bind().get(self)
@property
def folderURI(self):
if not self.productfolder:
return
pfn = grok.name.bind(get_default=default_name).get(self.productfolder)
return pfn.capitalize()
@property
def linkname(self):
return self.title
@property
def rolename(self):
return self.title
@property
def productfolder(self):
pfolder = productfolder.bind().get(self)
if pfolder:
return resolve(pfolder)
def invalidRole(self):
my_roles = uvcsite.IMyRoles(self.principal).getAllRoles()
if not self.folderURI in my_roles:
return True
return False
def available(self):
if self.invalidRole():
return False
return True
def action(self):
return "%s/%s/@@add" % (uvcsite.getHomeFolderUrl(
self.request), self.folderURI)
@property
def inNav(self):
return self.available()
@property
def asRole(self):
return self.available()
def createInProductFolder(self):
homefolder = IHomeFolder(self.principal).homeFolder
if not homefolder:
utility = getUtility(IHomeFolderManager)
utility.assignHomeFolder(uvcsite.IMasterUser(self.principal).id)
if self.folderURI and not self.folderURI in homefolder.keys():
pf = self.productfolder
homefolder[self.folderURI] = pf()
uvcsite.log('Add Productfolders %s to Homefolder: %s' %
(self.folderURI, self.principal.id),
severity=logging.DEBUG)
