def _toFieldValue(self, input):
if not input:
return self.context.missing_value
distribution = self.getDistribution()
cached_value = self.cached_values.get(input)
if cached_value:
return cached_value
if bool(getFeatureFlag('disclosure.dsp_picker.enabled')):
try:
self.context.vocabulary.setDistribution(distribution)
return self.context.vocabulary.getTermByToken(input).value
except LookupError:
raise ConversionError(
"Launchpad doesn't know of any source package named"
" '%s' in %s." % (input, distribution.displayname))
# Else the untrusted SPN vocab was used so it needs secondary
# verification.
try:
source = distribution.guessPublishedSourcePackageName(input)
except NotFoundError:
try:
source = self.convertTokensToValues([input])[0]
except InvalidValue:
raise ConversionError(
"Launchpad doesn't know of any source package named"
" '%s' in %s." % (input, distribution.displayname))
self.cached_values[input] = source
return source
class ImageInputWidget(FileWidget):
"""
render a inputwidget that displays the current
image and lets you choose to delete, replace or just
leave the current image as is.
"""
_missing = u""
__call__ = ViewPageTemplateFile("templates/image-widget.pt")
@property
def update_action_name(self):
return self.name + ".up_action"
@property
def upload_name(self):
return self.name.replace(".", "_") + "_file"
@property
def imageURL(self):
return "./file-image/%s" % self.context.__name__
def empty_field(self):
return self._data is None
def _getFieldInput(self, name):
return self.request.form.get(name, self._missing)
def _getFormInput(self):
"""extract the input value from the submitted form """
return (self._getFieldInput(self.update_action_name),
self._getFieldInput(self.upload_name))
def _toFieldValue(self, (update_action, upload)):
"""convert the input value to an value suitable for the field.
Check the update_action if we should leave the data alone,
delete or replace it.
"""
if update_action == u"update":
if upload is None or upload == "":
if self._data is None:
return self.context.missing_value
else:
raise ConversionError(
_("Form upload is not a file object"))
try:
seek = upload.seek
read = upload.read
except AttributeError, e:
raise ConversionError(
_("Form upload is not a file object"), e)
else:
seek(0)
data = read()
if data or getattr(upload, "filename", ""):
return data
else:
return self.context.missing_value
class DefaultFileInputWidget(FileWidget):
'''
This is the default FileInputWidget implementation,
other FileInputWidget types extend this
'''
_missing = u""
@property
def update_action_name(self):
return self.name + ".up_action"
@property
def upload_name(self):
return self.name.replace(".", "_") + "_file"
def empty_field(self):
return self._data is None
def _getFieldInput(self, name):
return self.request.form.get(name, self._missing)
def _getFormInput(self):
"""extract the input value from the submitted form """
return (self._getFieldInput(self.update_action_name),
self._getFieldInput(self.upload_name))
def _toFieldValue(self, (update_action, upload)):
"""convert the input value to an value suitable for the field.
Check the update_action if we should leave the data alone,
delete or replace it.
"""
if update_action == u"update":
if upload is None or upload == "":
if self._data is None:
return self.context.missing_value
else:
raise ConversionError(
_("Form upload is not a file object"))
try:
seek = upload.seek
read = upload.read
except AttributeError, e:
raise ConversionError(_("Form upload is not a file object"), e)
else:
seek(0)
data = read()
if data or getattr(upload, "filename", ""):
return data
else:
return self.context.missing_value
class TextDateTimeWidget(TextDateWidget):
__call__ = ViewPageTemplateFile("templates/text-datetime-widget.pt")
@property
def time_name(self):
return self.name.replace(".", "__") + "__time"
def hasInput(self):
return ((self.date_name in self.request.form
and self.time_name in self.request.form)
or (self.name in self.request.form))
def _hasPartialInput(self):
return (self.date_name in self.request.form
or self.time_name in self.request.form)
def _getFormInput(self):
"""extract the input value from the submitted form """
if not self.time_name in self.request.form:
return self._getFieldInput(self.name).split(" ")
return (self._getFieldInput(self.date_name),
self._getFieldInput(self.time_name))
def _toFormValue(self, value):
"""Convert a field value to a string that can be inserted into the form.
"""
if (value == self.context.missing_value) and self.required:
value = datetime.datetime.now()
try:
return (datetime.datetime.strftime(value, "%Y-%m-%d"),
datetime.datetime.strftime(value, "%H:%M"))
except:
#log.error("TextDateTimeWidget._toFormValue(%s) FAILED" % (value))
#debug.log_exc(sys.exc_info(), log_handler=log.error)
return ("", "12:00")
def _toFieldValue(self, (date, time)):
if (date == self._missing or time == self._missing):
if self.required:
return self.context.missing_value
else:
if date + time == self._missing:
return None
else:
return self.context.missing_value
else:
try:
d = datetime.datetime.strptime(date, "%Y-%m-%d")
t = datetime.datetime.strptime(time, "%H:%M")
return datetime.datetime(
year=d.year,
month=d.month,
day=d.day,
hour=t.hour,
minute=t.minute,
)
except ValueError, e:
raise ConversionError(
_("Incorrect string data for date and time"), e)
def _toFieldValue(self, input):
value = super(Bytes, self)._toFieldValue(input)
if type(value) is unicode:
try:
value = value.encode('ascii')
except UnicodeError, v:
raise ConversionError(_("Invalid textual data"), v)
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
return float(input)
except ValueError as v:
raise ConversionError(_("Invalid floating point data"), v)
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
return int(input)
except ValueError, v:
raise ConversionError(_("Invalid integer data"), v)
def _toFieldValue(self, input):
if input is None or input == '':
return self.context.missing_value
try:
seek = input.seek
read = input.read
except AttributeError, e:
raise ConversionError(_('Form input is not a file object'), e)
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
return decimal.Decimal(input)
except decimal.InvalidOperation as v:
raise ConversionError(_("Invalid decimal data"), v)
def _toFieldValue(self, input):
if not input:
return self.context.missing_value
try:
filename = input.filename.split('\\')[-1] # for IE
input.filename = filename.strip().replace(' ', '_')
except AttributeError, e:
raise ConversionError(zope_('Form input is not a file object'), e)
def _toFieldValue(self, input):
if input:
try:
return self.convertTokensToValues([input])[0]
except (InvalidValue, TypeError) as e:
raise ConversionError(_("Invalid value"), e)
else:
return self.context.missing_value
def _toFieldValue(self, input):
value = super(Bytes, self)._toFieldValue(input)
if isinstance(value, unicode):
try:
value = value.encode('ascii')
except UnicodeError as v:
raise ConversionError(_("Invalid textual data"), v)
return value
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
try:
return str(input.strip())
except (AttributeError, UnicodeEncodeError), err:
raise ConversionError(_(u'Invalid email address.'), err)
def _toFieldValue(self, value):
value = super(TextAreaWidget, self)._toFieldValue(value)
if value:
try:
value = unicode(value)
except ValueError, v:
raise ConversionError(_("Invalid unicode data"), v)
else:
value = value.replace("\r\n", "\n")
def _toFieldValue(self, input):
"""See SimpleInputWidget"""
if input is None:
input = []
elif not isinstance(input, list):
input = [input]
try:
values = self.convertTokensToValues(input)
except InvalidValue, e:
raise ConversionError(_("Invalid value"), e)
def _toFieldValue(self, date):
"""convert the input value to an value suitable for the field."""
if (date == self.context.missing_value) and self.required:
return self.context.missing_value
else:
try:
return datetime.datetime.strptime(date, "%Y-%m-%d").date()
except ValueError, e:
if date == "":
return
raise ConversionError(_(u"Incorrect string data for date"), e)
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
formatter = self.request.locale.dates.getFormatter(
self._category, (self.displayStyle or None))
return formatter.parse(input)
except (DateTimeParseError, ValueError) as v:
raise ConversionError(_("Invalid datetime data"),
"%s (%r)" % (v, input))
def _toFieldValue(self, input):
if input == self._missing:
return self.context.missing_value
else:
try:
# TODO: Currently datetimes return in local (server)
# time zone if no time zone information was given.
# Maybe offset-naive datetimes should be returned in
# this case? (DV)
return parseDatetimetz(input)
except (DateTimeError, ValueError, IndexError) as v:
raise ConversionError(_("Invalid datetime data"), v)
def _toFieldValue(self, input):
if self.convert_missing_value and input == self._missing:
value = self.context.missing_value
else:
# We convert everything to unicode. This might seem a bit crude,
# but anything contained in a TextWidget should be representable
# as a string. Note that you always have the choice of overriding
# the method.
try:
value = unicode(input)
except ValueError, v:
raise ConversionError(_("Invalid text data"), v)
def _toFieldValue(self, value):
if self.required and (value == self.context.missing_value):
return value
else:
try:
parsed = datetime.datetime.strptime(value, "%H:%M")
return value
except ValueError, e:
if value:
raise ConversionError(
_(u"Type in a valid time value in"
" 24H format e.g 00:00 - 23:59"), e)
def _toFieldValue(self, value):
dates = []
for token in itertools.chain(
*[line.split("\n") for line in value.split(",")]):
token = token.strip()
if not token:
continue
try:
date = parseDatetimetz(token)
dates.append(date.date())
except (DateTimeError, ValueError, IndexError), v:
raise ConversionError(
_("Invalid date: $value", mapping={"value": token}), v)
def _checkSupportedFormat(self, input):
"""Checks that the input is in a usable format."""
for fmt in self.supported_input_formats:
try:
datetime.strptime(input.strip(), fmt)
except (ValueError) as e:
if 'unconverted data remains' in str(e):
return
else:
failure = e
else:
return
if failure:
raise ConversionError('Invalid date value', failure)
def _toFieldValue(self, input):
"""See zope.formlib.widget.SimpleInputWidget."""
if input == self._missing:
return self.context.missing_value
else:
input = input.strip()
# Bug ids are often prefixed with '#', but getByNameOrID
# doesn't accept such ids.
if input.startswith('#'):
input = input[1:]
try:
return getUtility(IBugSet).getByNameOrID(input)
except (NotFoundError, ValueError):
raise ConversionError("Not a valid bug number or nickname.")
def _toFieldValue(self, input):
if input is None or input == '':
return self.context.missing_value
try:
seek = input.seek
read = input.read
except AttributeError as e:
raise ConversionError(_('Form input is not a file object'), e)
else:
seek(0)
data = read()
if data or getattr(input, 'filename', ''):
return data
else:
return self.context.missing_value
def _parseInput(self, input):
"""Convert a string to a datetime value.
>>> from zope.publisher.browser import TestRequest
>>> from zope.schema import Field
>>> field = Field(__name__='foo', title=u'Foo')
>>> widget = DateTimeWidget(field, TestRequest())
>>> widget.required_time_zone = pytz.timezone('UTC')
>>> widget.time_zone
<UTC>
The widget converts an empty string to the missing value:
>>> widget._parseInput('') == field.missing_value
True
The widget prints out times in UTC:
>>> print widget._parseInput('2006-01-01 12:00:00')
2006-01-01 12:00:00+00:00
But it will handle other time zones:
>>> widget.required_time_zone = pytz.timezone('Australia/Perth')
>>> print widget._parseInput('2006-01-01 12:00:00')
2006-01-01 12:00:00+08:00
Invalid dates result in a ConversionError:
>>> print widget._parseInput('not a date') #doctest: +ELLIPSIS
Traceback (most recent call last):
...
ConversionError: ('Invalid date value', ...)
"""
if input == self._missing:
return self.context.missing_value
self._checkSupportedFormat(input)
try:
year, month, day, hour, minute, second, dummy_tz = parse(input)
second, micro = divmod(second, 1.0)
micro = round(micro * 1000000)
dt = datetime(year, month, day,
hour, minute, int(second), int(micro))
except (DateTimeError, ValueError, IndexError) as v:
raise ConversionError('Invalid date value', v)
return self.time_zone.localize(dt)
def _toFieldValue(self, input):
if not input:
return self.context.missing_value
distribution = self.getDistribution()
cached_value = self.cached_values.get(input)
if cached_value:
return cached_value
try:
source = distribution.guessPublishedSourcePackageName(input)
except NotFoundError:
try:
source = self.convertTokensToValues([input])[0]
except InvalidValue:
raise ConversionError(
"Launchpad doesn't know of any source package named"
" '%s' in %s." % (input, distribution.displayname))
self.cached_values[input] = source
return source
def _toFieldValue(self, input):
"""See SimpleInputWidget"""
if input is None:
input = []
elif not isinstance(input, list):
input = [input]
try:
values = self.convertTokensToValues(input)
except InvalidValue as e:
raise ConversionError(_("Invalid value"), e)
# All AbstractCollection fields have a `_type` attribute specifying
# the type of collection. Use it to generate the correct type,
# otherwise return a list. TODO: this breaks encapsulation.
if hasattr(self.context, '_type'):
_type = self.context._type
if isinstance(_type, tuple):
_type = _type[0]
return _type(values)
else:
return values
class SelectDateTimeWidget(SelectDateWidget):
__call__ = ViewPageTemplateFile("templates/select-datetime-widget.pt")
@property
def _hour_name(self):
return self.name.replace(".", "__") + "__hour"
@property
def _minute_name(self):
return self.name.replace(".", "__") + "__minute"
def hasInput(self):
return (super(SelectDateTimeWidget, self).hasInput() and
self._hour_name in self.request.form and
self._minute_name in self.request.form)
def _hasPartialInput(self):
return (super(SelectDateTimeWidget, self)._hasPartialInput() or
self._hour_name in self.request.form or
self._minute_name in self.request.form)
def _getFormInput(self):
return (super(SelectDateTimeWidget, self)._getFormInput() +
(self._getFieldInput(self._hour_name),
self._getFieldInput(self._minute_name)))
def _hours(self):
hl = []
for i in range(0, 24):
hl.append("%02d" % (i))
return hl
def _minutes(self):
ml = []
for i in range(0, 60, 5):
ml.append("%02d" % (i))
return ml
def _toFormValue(self, value):
if value == self.context.missing_value and self.required:
d = datetime.datetime.now()
return (d.day, d.month, d.year, d.hour, d.minute)
else:
try:
return (value.day, value.month, value.year,
value.hour, value.minute)
except:
return ("0", "0", "0", "0", "0")
def _toFieldValue(self, (day, month, year, hour, minute)):
if (day == self._missing or
month == self._missing or
year == self._missing or
hour == self._missing or
minute == self._missing
):
if self.required:
return self.context.missing_value
else:
if day + month + year + hour + minute == self._missing:
return None
else:
return self.context.missing_value
else:
try:
time_zone = self.time_zone
return datetime.datetime(year=int(year), month=int(month),
day=int(day), hour=int(hour), minute=int(minute),)
except ValueError, e:
raise ConversionError(
_(u"Incorrect string data for date and time"), e)
class SelectDateWidget(zope.formlib.widget.SimpleInputWidget):
"""A more user freindly date input.
"""
__call__ = ViewPageTemplateFile("templates/select-date-widget.pt")
_missing = u""
minYear = None
maxYear = None
minYearDelta = 100
maxYearDelta = 5
js_file = open(path + "/templates/yui-calwidget.js", "r")
js_template = js_file.read()
js_file.close()
def __init__(self, *args):
super(SelectDateWidget, self).__init__(*args)
need("yui-calendar")
need("yui-container")
need("yui-element")
need("yui-button")
self.minDate = datetime.date.today() - datetime.timedelta(
self.minYearDelta * 365)
self.maxDate = datetime.date.today() + datetime.timedelta(
self.maxYearDelta * 365)
@property
def time_zone(self):
"""Returns something like:
tzinfo=<DstTzInfo 'Africa/Nairobi' LMT+2:27:00 STD>
"""
try:
time_zone = idatetime.ITZInfo(self.request)
except TypeError:
time_zone = pytz.UTC
return time_zone
@property
def field_name(self):
return self.name.replace(".", "__")
def set_min_date(self, date):
if date:
if type(date) == datetime.date:
self.minDate = date
elif type(date) == datetime.datetime:
self.minDate = date.date()
else:
self.minDate = (datetime.date.today() -
datetime.timedelta(self.minYearDelta * 365))
else:
self.minDate = (datetime.date.today() -
datetime.timedelta(self.minYearDelta * 365))
def set_max_date(self, date):
if date:
if type(date) == datetime.date:
self.maxDate = date
elif type(date) == datetime.datetime:
self.maxDate = date.date()
else:
self.maxDate = (datetime.date.today() +
datetime.timedelta(self.maxYearDelta * 365))
else:
self.maxDate = (datetime.date.today() +
datetime.timedelta(self.maxYearDelta * 365))
def jstr(self, alist):
return u'["' + u'", "'.join(alist) + u'"]'
def get_js(self):
pagedate = datetime.date.today()
if self.maxDate < pagedate:
pagedate = self.maxDate
if ((type(self._data) == datetime.date) or
(type(self._data) == datetime.datetime)
):
pagedate = self._data
calendar = self.request.locale.dates.calendars["gregorian"]
month = _(u"Choose Month")
year = _(u"Enter Year")
submit = _("OK")
cancel = _(u"Cancel")
invalidYear = _(u"Please enter a valid year")
months_short = self.jstr(calendar.getMonthAbbreviations())
months_long = self.jstr(calendar.getMonthNames())
w_day_1char = self.jstr(
[dn[:1] for dn in calendar.getDayAbbreviations()])
w_day_short = self.jstr(
[dn[:2] for dn in calendar.getDayAbbreviations()])
w_day_medium = self.jstr(calendar.getDayAbbreviations())
w_day_long = self.jstr(calendar.getDayNames())
return self.js_template % {
"name": self.field_name,
"sel_day": self._day_name,
"sel_month": self._month_name,
"sel_year": self._year_name,
"txt_date": self.date_name,
"mindate": self.minDate.strftime("%m/%d/%Y"),
"maxdate": self.maxDate.strftime("%m/%d/%Y"),
"pagedate": pagedate.strftime("%m/%Y"),
"months_short": months_short,
"months_long": months_long,
"w_day_1char": w_day_1char,
"w_day_short": w_day_short,
"w_day_medium": w_day_medium,
"w_day_long": w_day_long,
"month": translate(
str(month), domain="bungeni", context=self.request),
"year": translate(
str(year), domain="bungeni", context=self.request),
"submit": translate(
str(submit), domain="bungeni", context=self.request),
"cancel": translate(
str(cancel), domain="bungeni", context=self.request),
"invalidYear": translate(
str(invalidYear), domain="bungeni", context=self.request)
}
def _days(self):
dl = []
for i in range(1, 32):
dl.append("%02d" % (i))
return dl
def _months(self):
""" return a dict of month values and names"""
calendar = self.request.locale.dates.calendars["gregorian"]
i = 0
months = []
for month in calendar.getMonthNames():
i = i + 1
months.append({"num": "%02d" % i, "name": month})
return months
@property
def _years(self):
minYear = self.minYear
if self.minDate:
minYear = self.minDate.year
if minYear is None:
minYear = datetime.date.today().year - int(self.minYearDelta)
maxYear = self.maxYear
if self.maxDate:
maxYear = self.maxDate.year
if maxYear is None:
maxYear = datetime.date.today().year + int(self.maxYearDelta)
return range(maxYear, minYear - 1, -1)
@property
def _day_name(self):
return self.name.replace(".", "__") + "__day"
@property
def _month_name(self):
return self.name.replace(".", "__") + "__month"
@property
def _year_name(self):
return self.name.replace(".", "__") + "__year"
@property
def date_name(self):
return self.name.replace(".", "__") + "__date"
def hasInput(self):
"""Widgets need to determine whether the request contains an input
value for them """
return (self._day_name in self.request.form and
self._month_name in self.request.form and
self._year_name in self.request.form)
def _hasPartialInput(self):
return (self._day_name in self.request.form or
self._month_name in self.request.form or
self._year_name in self.request.form)
def _getFormInput(self):
"""extract the input value from the submitted form """
return (self._getFieldInput(self._day_name),
self._getFieldInput(self._month_name),
self._getFieldInput(self._year_name))
def _getFieldInput(self, name):
return self.request.form.get(name, self._missing)
def _toFieldValue(self, (day, month, year)):
"""convert the input value to an value suitable for the field."""
if day == self._missing or month == self._missing or year == self._missing:
if self.required:
return self.context.missing_value
else:
if day + month + year == self._missing:
return None
else:
return self.context.missing_value
else:
try:
time_zone = self.time_zone
return datetime.date(
year=int(year), month=int(month), day=int(day)
) #tzinfo=time_zone)
except ValueError, e:
raise ConversionError(_(u"Incorrect string data for date"), e)
data = read()
if data or getattr(upload, "filename", ""):
return data
else:
return self.context.missing_value
elif update_action == u"delete":
return None
elif update_action == u"add":
if upload is None or upload == "":
return None
else:
try:
seek = upload.seek
read = upload.read
except AttributeError, e:
raise ConversionError(
_("Form upload is not a file object"), e)
else:
seek(0)
data = read()
if data or getattr(upload, "filename", ""):
return data
else:
return self.context.missing_value
else:
raise NotImplementedError
return
def hasInput(self):
"""
determins if the widget widget has changed
"""
