class BodyAdapterBase(NodeAdapterBase):
"""Body im- and exporter base.
"""
implementsOnly(IBody)
def _exportSimpleNode(self):
"""Export the object as a DOM node.
"""
return self._getObjectNode('object', False)
def _importSimpleNode(self, node):
"""Import the object from the DOM node.
"""
node = property(_exportSimpleNode, _importSimpleNode)
def _exportBody(self):
"""Export the object as a file body.
"""
return ''
def _importBody(self, body):
"""Import the object from the file body.
"""
body = property(_exportBody, _importBody)
mime_type = 'text/plain'
name = ''
suffix = ''
class DateWidget(BaseWidget, HTMLInputWidget):
"""Date widget for z3c.form."""
_base = InputWidget
_converter = DateWidgetConverter
_formater = 'date'
implementsOnly(IDateWidget)
pattern = 'pickadate'
pattern_options = BaseWidget.pattern_options.copy()
def _base_args(self):
"""Method which will calculate _base class arguments.
Returns (as python dictionary):
- `pattern`: pattern name
- `pattern_options`: pattern options
- `name`: field name
- `value`: field value
:returns: Arguments which will be passed to _base
:rtype: dict
"""
args = super(DateWidget, self)._base_args()
args['name'] = self.name
args['value'] = (self.request.get(self.name, self.value)
or u'').strip()
args.setdefault('pattern_options', {})
args['pattern_options'] = dict_merge(get_date_options(self.request),
args['pattern_options'])
return args
def render(self):
"""Render widget.
:returns: Widget's HTML.
:rtype: string
"""
if self.mode != 'display':
return super(DateWidget, self).render()
if not self.value:
return ''
field_value = self._converter(self.field,
self).toFieldValue(self.value)
if field_value is self.field.missing_value:
return u''
formatter = self.request.locale.dates.getFormatter(
self._formater, "short")
if field_value.year > 1900:
return formatter.format(field_value)
# due to fantastic datetime.strftime we need this hack
# for now ctime is default
return field_value.ctime()
class XMLAdapterBase(BodyAdapterBase):
"""XML im- and exporter base.
"""
implementsOnly(IBody)
def _exportBody(self):
"""Export the object as a file body.
"""
self._doc.appendChild(self._exportNode())
xml = self._doc.toprettyxml(' ')
self._doc.unlink()
return xml
def _importBody(self, body):
"""Import the object from the file body.
"""
try:
dom = parseString(body)
except ExpatError, e:
filename = (self.filename or
'/'.join(self.context.getPhysicalPath()))
raise ExpatError('%s: %s' % (filename, e))
self._importNode(dom.documentElement)
class Client(tcp.Client):
"""I am an SSL client."""
implementsOnly(
interfaces.ISSLTransport, *[
i for i in implementedBy(tcp.Client)
if i != interfaces.ITLSTransport
])
def __init__(self,
host,
port,
bindAddress,
ctxFactory,
connector,
reactor=None):
# tcp.Client.__init__ depends on self.ctxFactory being set
self.ctxFactory = ctxFactory
tcp.Client.__init__(self, host, port, bindAddress, connector, reactor)
def getHost(self):
"""Returns the address from which I am connecting."""
h, p = self.socket.getsockname()
return address.IPv4Address('TCP', h, p, 'SSL')
def getPeer(self):
"""Returns the address that I am connected."""
return address.IPv4Address('TCP', self.addr[0], self.addr[1], 'SSL')
def _connectDone(self):
self.startTLS(self.ctxFactory)
self.startWriting()
tcp.Client._connectDone(self)
class SimpleRichTextWidget(TextAreaWidget):
"""
A widget that implements the rte-light editor
http://code.google.com/p/rte-light/
"""
implementsOnly(ISimpleRichTextWidget)
klass = u"simple-rich-text-widget"
def rte_conf(self):
conf = {}
conf['iframe_height'] = getattr(self.field, 'iframe_height', 100)
conf['format_block'] = str(getattr(self.field, 'format_block',
True)).lower()
conf['bold'] = str(getattr(self.field, 'bold', True)).lower()
conf['italic'] = str(getattr(self.field, 'italic', True)).lower()
conf['unordered_list'] = str(
getattr(self.field, 'unordered_list', True)).lower()
conf['link'] = str(getattr(self.field, 'link', True)).lower()
conf['image'] = str(getattr(self.field, 'image', True)).lower()
conf['allow_disable'] = str(getattr(self.field, 'allow_disable',
True)).lower()
return conf
class WorkspaceContainerTraverser(SimpleComponentTraverser):
"""Custom Workspace (domain IBungeniGroup object) container traverser.
This object is the "root" of each user's workspace.
"""
interface.implementsOnly(IPublishTraverse)
component.adapts(interfaces.IWorkspaceContainer, IHTTPRequest)
def __init__(self, context, request):
assert interfaces.IWorkspaceContainer.providedBy(context)
self.context = context # workspace domain object
self.request = request
log.debug(" __init__ %s context=%s url=%s" %
(self, self.context, request.getURL()))
def publishTraverse(self, request, name):
workspace = self.context
_meth_id = "%s.publishTraverse" % self.__class__.__name__
log.debug("%s: name=%s context=%s " % (_meth_id, name, workspace))
if name == "pi":
return getWorkSpacePISection(workspace)
elif name == "archive":
return getWorkSpaceArchiveSection(workspace)
elif name == "mi":
return getWorkSpaceMISection(workspace)
return super(WorkspaceContainerTraverser,
self).publishTraverse(request, name)
class Client(tcp.Client):
"""
I am an SSL client.
"""
implementsOnly(
interfaces.ISSLTransport, *[
i for i in implementedBy(tcp.Client)
if i != interfaces.ITLSTransport
])
def __init__(self,
host,
port,
bindAddress,
ctxFactory,
connector,
reactor=None):
# tcp.Client.__init__ depends on self.ctxFactory being set
self.ctxFactory = ctxFactory
tcp.Client.__init__(self, host, port, bindAddress, connector, reactor)
def _connectDone(self):
self.startTLS(self.ctxFactory)
self.startWriting()
tcp.Client._connectDone(self)
class QueryStringWidget(BaseWidget, z3cform_TextWidget):
"""QueryString widget for z3c.form."""
_base = InputWidget
implementsOnly(IQueryStringWidget)
pattern = 'querystring'
pattern_options = BaseWidget.pattern_options.copy()
querystring_view = '@@qsOptions'
def _base_args(self):
"""Method which will calculate _base class arguments.
Returns (as python dictionary):
- `pattern`: pattern name
- `pattern_options`: pattern options
- `name`: field name
- `value`: field value
:returns: Arguments which will be passed to _base
:rtype: dict
"""
args = super(QueryStringWidget, self)._base_args()
args['name'] = self.name
args['value'] = self.value
args.setdefault('pattern_options', {})
args['pattern_options'] = dict_merge(
get_querystring_options(self.context, self.querystring_view),
args['pattern_options'])
return args
class AbsoluteURL(zope.traversing.browser.absoluteurl.AbsoluteURL):
implementsOnly(IAbsoluteURL)
adapts(IResource, IBrowserRequest)
def __init__(self, context, request):
self.context = context
self.request = request
def _createUrl(self, baseUrl, name):
return "%s/@@/%s" % (baseUrl, name)
def __str__(self):
name = self.context.__name__
if name.startswith('++resource++'):
name = name[12:]
site = zope.component.hooks.getSite()
base = queryMultiAdapter((site, self.request),
IAbsoluteURL,
name="resource")
if base is None:
url = str(getMultiAdapter((site, self.request), IAbsoluteURL))
else:
url = str(base)
return self._createUrl(url, name)
class TextLineMultiChoiceField(TextLineChoiceField):
interface.implementsOnly(se_schema.ITextLineChoice)
component.adapts(schema_ifaces.ISet)
def __init__(self, field):
self.__dict__['field'] = field
def __getattr__(self, name):
if name == 'values':
return [
term.value for term in (self.field.value_type.vocabulary or [])
]
return getattr(self.field, name)
def __setattr__(self, name, value):
if name == 'values' and value:
vocab = self._constructVocabulary(value)
return setattr(self.field.value_type, 'vocabulary', vocab)
elif name == 'values' and not value:
return
if name == 'vocabularyName' and value:
setattr(self.field.value_type, 'values', None)
setattr(self.field.value_type, 'vocabulary', None)
setattr(self.field.value_type, 'vocabularyName', value)
return setattr(self.field, 'vocabularyName', value)
elif name == 'vocabularyName' and not value:
setattr(self.field.value_type, 'vocabularyName', None)
return setattr(self.field, 'vocabularyName', None)
return setattr(self.field, name, value)
class SchedulingContextTraverser(SimpleComponentTraverser):
"""Custom scheduling context traverser which allows traversing to
calendar days (using integer timestamps) or a ``get_%s`` method
from the scheduling context class.
"""
component.adapts(ISchedulingContext, IHTTPRequest)
interface.implementsOnly(IPublishTraverse)
def publishTraverse(self, request, name):
try:
timestamp = int(name)
obj = DailySchedulingContext(
self.context, utils.datetimedict.fromtimestamp(timestamp))
except (ValueError, TypeError):
# this is the primary condition; traverse to ``name`` by
# looking up methods on this class
try:
method = getattr(self.context, 'get_%s' % name)
except AttributeError:
# fall back to default traversal (view lookup)
def method():
return super(SchedulingContextTraverser,
self).publishTraverse(request, name)
obj = method()
assert ILocation.providedBy(obj)
log.debug("SchedulingContextTraverser.publishTraverse: " \
"self=%s context=%s name=%s obj=%s" % (self, self.context, name, obj))
return ProxyFactory(
LocationProxy(removeSecurityProxy(obj),
container=self.context,
name=name))
class DummySite(FiveTraversableFolder):
"""A very dummy Site
"""
# we specifically do not let this site inherit any interfaces from
# the superclasses so that this class does not implement
# IPossibleSite under any circumstances
implementsOnly(IDummySite)
class RelatedItemsWidget(Select2Widget):
_widget_klass = base.Select2Widget
implementsOnly(IRelatedItemsWidget)
pattern = 'relateditems'
pattern_options = Select2Widget.pattern_options.copy()
class DateWidget(base.AbstractDateWidget, AbstractDXDateWidget):
""" Date widget.
Please note: zope.schema date/datetime field values are python datetime
instances.
"""
implementsOnly(IDateWidget)
class RecurrenceWidget(TextAreaWidget):
"""Recurrence widget implementation."""
implementsOnly(IRecurrenceWidget)
klass = u'recurrence-widget'
value = u''
start_field = None
show_repeat_forever = True
def site_url(self):
return absoluteURL(getSite(), self.request)
def translation(self):
return translations(self.request)
def read_only(self):
return self.mode == 'display'
def get_start_field(self):
if self.mode == 'display':
return self.id + '-start'
if hasattr(self.form.widgets[self.start_field], 'js_field'):
return self.form.widgets[self.start_field].js_field
if hasattr(self.form.widgets[self.start_field], 'name'):
# plone.app.widgets passes name instead of id to input
return self.form.widgets[self.start_field].name
return self.form.widgets[self.start_field].id
def get_start_date(self):
start = self.form.fields[self.start_field].field.get(self.context)
return start.strftime('%Y-%m-%d %H:%M')
def first_day(self):
""" First day of the Week. 0..Sunday, 6..Saturday.
.. Note::
This value is likely to be overwritten by the widget configuration.
"""
calendar = self.request.locale.dates.calendars[u'gregorian']
return calendar.week.get('firstDay', 0)
def get_recurrenceinput_params(self):
portal = getToolByName(getSite(), 'portal_url').getPortalObject()
ajax_url = portal.absolute_url() + '/@@json_recurrence'
params = dict(
ajaxContentType='application/x-www-form-urlencoded; charset=UTF-8',
ajaxURL=ajax_url,
firstDay=self.first_day(),
hasRepeatForeverButton=self.show_repeat_forever,
lang=self.request.LANGUAGE,
readOnly=self.read_only(),
ributtonExtraClass='allowMultiSubmit',
startField=self.get_start_field(),
)
return params
def js_recurrenceinput_params(self):
return json.dumps(self.get_recurrenceinput_params())
class ReCaptchaWidget(text.TextWidget):
maxlength = 7
size = 8
implementsOnly(IReCaptchaWidget)
def public_key(self):
registry = getUtility(IRegistry)
return registry.get('castle.recaptcha_public_key', '')
class InputMarkdownWidget(HTMLTextAreaWidget, Widget):
implementsOnly(IMarkdownWidget)
klass = u'markdown-widget'
value = u''
def update(self):
super(InputMarkdownWidget, self).update()
addFieldClass(self)
class DatetimeWidget(base.AbstractDatetimeWidget, AbstractDXDateWidget):
""" DateTime widget """
implementsOnly(IDatetimeWidget)
def extract(self, default=NOVALUE):
# get normal input fields
day = self.request.get(self.name + '-day', default)
month = self.request.get(self.name + '-month', default)
year = self.request.get(self.name + '-year', default)
hour = self.request.get(self.name + '-hour', default)
minute = self.request.get(self.name + '-minute', default)
timezone = self.request.get(self.name + '-timezone', default)
if (self.ampm is True and hour is not default and minute is not default
and hour):
ampm = self.request.get(self.name + '-ampm', default)
if ampm == 'PM':
if hour != u'12':
hour = str(12 + int(hour))
elif ampm == 'AM':
if hour == u'12':
hour = u'00' # 12 a.m. midnight hour == 00:**
# something strange happened since we either
# should have 'PM' or 'AM', return default
elif ampm != 'AM':
return default
if default not in (year, month, day, hour, minute):
dt = (year, month, day, hour, minute)
if timezone != default:
# can be naive datetime
dt += (timezone, )
return dt
# get a hidden value
formatter = self._dtformatter
try:
if formatter is not None:
hidden_date = self.request.get(self.name, '')
dateobj = formatter.parse(hidden_date)
tz = getattr(dateobj, 'tzinfo', '')
if tz:
tz = str(tz)
else:
ts = ''
return (
str(dateobj.year),
str(dateobj.month),
str(dateobj.day),
str(dateobj.hour),
str(dateobj.minute),
tz,
)
except DateTimeParseError:
pass
return default
class RelatedItemsWidget(BaseWidget, z3cform_TextWidget):
"""RelatedItems widget for z3c.form."""
_base = InputWidget
implementsOnly(IRelatedItemsWidget)
pattern = 'relateditems'
pattern_options = BaseWidget.pattern_options.copy()
separator = ';'
vocabulary = 'plone.app.vocabularies.Catalog'
vocabulary_view = '@@getVocabulary'
orderable = False
def _base_args(self):
"""Method which will calculate _base class arguments.
Returns (as python dictionary):
- `pattern`: pattern name
- `pattern_options`: pattern options
- `name`: field name
- `value`: field value
:returns: Arguments which will be passed to _base
:rtype: dict
"""
args = super(RelatedItemsWidget, self)._base_args()
args['name'] = self.name
args['value'] = self.value
args.setdefault('pattern_options', {})
vocabulary_name = self.vocabulary
field = None
if IChoice.providedBy(self.field):
args['pattern_options']['maximumSelectionSize'] = 1
field = self.field
elif ICollection.providedBy(self.field):
field = self.field.value_type
if field is not None and field.vocabularyName:
vocabulary_name = field.vocabularyName
field_name = self.field and self.field.__name__ or None
args['pattern_options'] = dict_merge(
get_relateditems_options(self.context, args['value'],
self.separator, vocabulary_name,
self.vocabulary_view, field_name),
args['pattern_options'])
if field and getattr(field, 'vocabulary', None):
form_url = self.request.getURL()
source_url = "%s/++widget++%s/@@getSource" % (form_url, self.name)
args['pattern_options']['vocabularyUrl'] = source_url
return args
class MultiLanguageExtraOptionsAdapter(LanguageControlPanelAdapter):
implementsOnly(IMultiLanguageExtraOptionsSetupSchema)
def __init__(self, context):
super(MultiLanguageExtraOptionsAdapter, self).__init__(context)
self.registry = getUtility(IRegistry)
self.settings = self.registry.forInterface(
IMultiLanguageExtraOptionsSchema)
def get_filter_content(self):
return self.settings.filter_content
def set_filter_content(self, value):
self.settings.filter_content = value
def get_google_translation_key(self):
return self.settings.google_translation_key
def set_google_translation_key(self, value):
self.settings.google_translation_key = value
def get_redirect_babel_view(self):
return self.settings.redirect_babel_view
def set_redirect_babel_view(self, value):
self.settings.redirect_babel_view = value
def get_set_default_language(self):
return False
def set_set_default_language(self, value):
if value:
SetupMultilingualSite(self.context).set_default_language_content()
def get_move_content_to_language_folder(self):
return False
def set_move_content_to_language_folder(self, value):
if value:
SetupMultilingualSite(self.context).move_default_language_content()
google_translation_key = property(get_google_translation_key,
set_google_translation_key)
filter_content = property(get_filter_content,
set_filter_content)
redirect_babel_view = property(get_redirect_babel_view,
set_redirect_babel_view)
set_default_language = property(get_set_default_language,
set_set_default_language)
move_content_to_language_folder = property(
get_move_content_to_language_folder,
set_move_content_to_language_folder)
class I18NTextAreaWidget(I18NWidget, textarea.TextAreaWidget):
"""I18N text input type implementation."""
implementsOnly(II18NTextAreaWidget)
default_widget = textarea.TextAreaWidget
rows = I18NWidgetProperty('rows')
cols = I18NWidgetProperty('cols')
readonly = I18NWidgetProperty('readonly')
onselect = I18NWidgetProperty('onselect')
class ConnectedDatagramPort(DatagramPort):
"""
A connected datagram UNIX socket.
"""
implementsOnly(interfaces.IUNIXDatagramConnectedTransport,
*(implementedBy(base.BasePort)))
def __init__(self, addr, proto, maxPacketSize=8192, mode=0666,
bindAddress=None, reactor=None):
class CkeditorZ3CFormWidget(TextAreaWidget,
HTMLFragmentWidget,
CkeditorWidgetBase):
"""CKEditor z3c.form widget implementation."""
implementsOnly(ICkeditorWidget)
config = None
value = u''
_adapterValueAttributes = Widget._adapterValueAttributes + ('config', )
class FileUploadFieldsWidget(MapPointsWidget):
implementsOnly(IFileUploadFieldsWidget)
pattern = 'fileuploadfieldswidget'
def _base_args(self):
args = super(FileUploadFieldsWidget, self)._base_args()
args['name'] = self.name
args['value'] = (self.request.get(self.name, self.value)
or u'[]').strip()
return args
class ManagePortlets(ManageContextualPortlets):
"""View used for the edit screen
"""
implementsOnly(IManagePortletPagePortletsView)
__call__ = ViewPageTemplateFile('manage-portletpage-portlets.pt')
def __init__(self, context, request):
# Skip past the main parent constructor, since it sets disable_border
super(ManageContextualPortlets, self).__init__(context, request)
class MapMarkersWidget(JsonListWidget):
implementsOnly(IMapMarkersWidget)
pattern = 'mapselect'
pattern_options = JsonListWidget.pattern_options.copy()
def _base_args(self):
args = super(MapMarkersWidget, self)._base_args()
args.setdefault('pattern_options')
args['pattern_options']['type'] = 'markers'
return args
class StripeTokenWidget(text.TextWidget):
"""A widget for a named file object
"""
implementsOnly(IFieldWidget)
klass = u'stripe-token-widget'
value = None # don't default to a string
def extract(self, default=NOVALUE):
value = super(StripeTokenWidget, self).extract(default)
return value
class MonthYearWidget(base.AbstractMonthYearWidget, AbstractDXDateWidget):
""" Month and year widget """
implementsOnly(IMonthYearWidget)
def extract(self, default=NOVALUE):
day = self.request.get(self.name + '-day', default)
year = self.request.get(self.name + '-year', default)
month = self.request.get(self.name + '-month', default)
# only make default for day if year/month are set !
if ((not default in (year, month)) and (day == default)):
self.request.form[self.name + '-day'] = '1'
return AbstractDXDateWidget.extract(self)
class I18NTextWidget(I18NWidget, text.TextWidget):
"""I18N text input type implementation."""
implementsOnly(II18NTextWidget)
default_widget = text.TextWidget
maxlength = I18NWidgetProperty('maxlength')
size = I18NWidgetProperty('size')
def updateWidget(self, widget, language):
super(I18NTextWidget, self).updateWidget(widget, language)
widget.maxlength = widget.field.max_length
class ConnectionUserAndKey(ConnectionKey):
"""
Base connection which accepts a user_id and key
"""
interface.implementsOnly(IConnectionUserAndKey)
interface.classProvides(IConnectionUserAndKey)
user_id = None
def __init__(self, user_id, key, secure=True):
super(ConnectionUserAndKey, self).__init__(key, secure)
self.user_id = user_id
