class EnrollmentForm(Form):
study = ModelField(db_session=db_session,
class_=models.Study,
validators=[
wtforms.validators.InputRequired(),
check_cannot_edit_study
])
consent_date = DateField(validators=[
wtforms.validators.InputRequired(),
DateRange(
min=date(1900, 1, 1)), check_unique, check_consent_timeline
])
latest_consent_date = DateField(validators=[
wtforms.validators.InputRequired(),
DateRange(min=date(1900, 1, 1)), check_consent_timeline
])
termination_date = DateField(validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1)), check_termination_timeline
])
reference_number = wtforms.StringField(
validators=[wtforms.validators.Optional(), check_reference])
class LookingForFlightForm(Form):
airport_dict_name, _, _ = mu.read_airport_dict()
airports = ['%s - %s' % (v, k) for k, v in airport_dict_name.iteritems()]
airport_values = airport_dict_name.keys() + airport_dict_name.values(
) + airports
airport_validator = AnyOf(
airport_values, message=u'Invalid input, must be an airport name.')
date = DateField('Date', validators=[Required(), date_after_today])
origin = TextField('Origin', validators=[Required(), airport_validator])
destination = TextField('Destination',
validators=[Required(), airport_validator])
class SurgeryForm(FlaskForm):
cepod = SelectField('CEPOD',
choices=choice_for_enum(Cepod, include_blank=False),
coerce=coerce_for_enum(Cepod))
date_of_discharge = DateField('Date')
side = SelectField('Side',
choices=choice_for_enum(Side, include_blank=False),
coerce=coerce_for_enum(Side))
primary = BooleanField('Primary?')
type = SelectField('Type',
choices=choice_for_enum(Type, include_blank=False),
coerce=coerce_for_enum(Type))
additional_procedure = TextAreaField('Additional Procedure')
antibiotics = TextAreaField('Antibiotics')
comments = TextAreaField('Comments')
opd_rv_date = DateField('RV Date')
opd_pain = StringField('Pain')
opd_numbness = StringField('Numbness')
opd_infection = StringField('Infection')
opd_comments = TextAreaField('Comments')
class SpecimenAliquotForm(wtforms.Form):
"""
Similar form to Aliquot, except the fields are conditionally required
if they are selected
"""
ui_selected = wtforms.BooleanField()
id = wtforms.IntegerField(widget=wtforms.widgets.HiddenInput())
amount = wtforms.DecimalField(places=1,
validators=[required_if('ui_selected')])
collect_date = DateField(validators=[
required_if('ui_selected'),
DateRange(min=date(1900, 1, 1))
])
collect_time = TimeField(validators=[required_if('ui_selected')])
freezer = wtforms.StringField(
validators=[wtforms.validators.optional()])
rack = wtforms.StringField(validators=[wtforms.validators.optional()])
box = wtforms.StringField(validators=[wtforms.validators.optional()])
notes = wtforms.TextAreaField(
validators=[wtforms.validators.optional()])
count = wtforms.IntegerField(validators=[
required_if('ui_selected'),
wtforms.validators.optional()
])
aliquot_type_id = wtforms.SelectField(
coerce=int, validators=[required_if('ui_selected')])
def __init__(self, *args, **kw):
super(SpecimenAliquotForm, self).__init__(*args, **kw)
specimen = None
if 'obj' in kw:
obj = kw['obj']
if isinstance(obj, models.Specimen):
specimen = obj
elif isinstance(obj, models.Aliquot):
specimen = obj.specimen
elif 'specimen' in kw:
specimen = kw['specimen']
if specimen:
self.aliquot_type_id.choices = [
(t.id, t.title)
for t in specimen.specimen_type.aliquot_types.values()
]
else:
self.aliquot_type_id.choices = []
class VCRoomListFilterForm(IndicoForm):
direction = SelectField(_('Sort direction'), [DataRequired()],
choices=[('asc', _('Ascending')), ('desc', _('Descending'))])
abs_start_date = DateField(_('Start Date'), [Optional(), Exclusive('rel_start_date')],
parse_kwargs={'dayfirst': True})
abs_end_date = DateField(_('End Date'), [Optional(), Exclusive('rel_end_date')],
parse_kwargs={'dayfirst': True})
rel_start_date = IntegerField(_('Days in the past'), [Optional(), Exclusive('abs_start_date'), NumberRange(min=0)],
default=0)
rel_end_date = IntegerField(_('Days in the future'), [Optional(), Exclusive('abs_end_date'), NumberRange(min=0)],
default=7)
@generated_data
def start_date(self):
if self.abs_start_date.data is None and self.rel_start_date.data is None:
return None
return self.abs_start_date.data or (date.today() - timedelta(days=self.rel_start_date.data))
@generated_data
def end_date(self):
if self.abs_end_date.data is None and self.rel_end_date.data is None:
return None
return self.abs_end_date.data or (date.today() + timedelta(days=self.rel_end_date.data))
class BookingSearchForm(IndicoForm):
__generated_data__ = ('start_dt', 'end_dt')
room_ids = SelectMultipleField('Rooms', [DataRequired()], coerce=int)
start_date = DateField('Start Date', [InputRequired()],
parse_kwargs={'dayfirst': True})
start_time = TimeField('Start Time', [InputRequired()])
end_date = DateField('End Date', [InputRequired()],
parse_kwargs={'dayfirst': True})
end_time = TimeField('End Time', [InputRequired()])
booked_for_name = StringField('Booked For Name')
reason = StringField('Reason')
is_only_mine = BooleanField('Only Mine')
is_only_my_rooms = BooleanField('Only My Rooms')
is_only_confirmed_bookings = BooleanField('Only Confirmed Bookings')
is_only_pending_bookings = BooleanField('Only Prebookings')
is_rejected = BooleanField('Is Rejected')
is_cancelled = BooleanField('Is Cancelled')
is_archived = BooleanField('Is Archived')
uses_vc = BooleanField('Uses Video Conference')
needs_vc_assistance = BooleanField('Video Conference Setup Assistance')
needs_assistance = BooleanField('General Assistance')
@property
def start_dt(self):
return DataWrapper(
datetime.combine(self.start_date.data, self.start_time.data))
@property
def end_dt(self):
return DataWrapper(
datetime.combine(self.end_date.data, self.end_time.data))
class FilterForm(wtforms.Form):
pid = wtforms.StringField(_(u'PID'),
validators=[wtforms.validators.Optional()])
aliquot_types = wtforms.SelectMultipleField(
_(u'Aliquot Types'),
choices=available_types,
coerce=int,
validators=[wtforms.validators.Optional()])
aliquot_states = wtforms.SelectMultipleField(
_(u'Aliquot States'),
choices=available_states,
coerce=int,
validators=[wtforms.validators.Optional()])
visit_cycles = wtforms.SelectMultipleField(
_(u'Visit Cycles'),
choices=available_cycles,
coerce=int,
validators=[wtforms.validators.Optional()])
from_ = DateField(_(u'From Date'),
validators=[wtforms.validators.Optional()])
to = DateField(_(u'To Date'),
validators=[wtforms.validators.Optional()])
freezer = wtforms.StringField(
_(u'Freezer'), validators=[wtforms.validators.Optional()])
rack = wtforms.StringField(_(u'Rack'),
validators=[wtforms.validators.Optional()])
box = wtforms.StringField(_(u'Box'),
validators=[wtforms.validators.Optional()])
class FilterForm(wtforms.Form):
pid = wtforms.StringField(
_(u'PID'),
validators=[wtforms.validators.Optional()])
specimen_types = wtforms.SelectMultipleField(
_(u'Specimen Types'),
choices=available_types,
coerce=int,
validators=[wtforms.validators.Optional()])
specimen_states = wtforms.SelectMultipleField(
_(u'Specimen States'),
choices=available_states,
coerce=int,
validators=[wtforms.validators.Optional()])
visit_cycles = wtforms.SelectMultipleField(
_(u'Visit Cycles'),
choices=available_cycles,
coerce=int,
validators=[wtforms.validators.Optional()])
from_ = DateField(
_(u'From Date'),
validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1))
])
to = DateField(
_(u'To Date'),
validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1))
])
class CheckoutForm(wtforms.Form):
ui_selected = wtforms.BooleanField()
id = wtforms.IntegerField(widget=wtforms.widgets.HiddenInput())
location_id = wtforms.SelectField(
choices=available_locations,
coerce=int,
validators=[wtforms.validators.DataRequired()])
sent_date = DateField(validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1))
])
sent_name = wtforms.StringField(
validators=[wtforms.validators.Optional()])
sent_notes = wtforms.TextAreaField(
validators=[wtforms.validators.Optional()])
class VisitForm(Form):
cycles = wtforms.FieldList(
ModelField(
db_session=db_session,
class_=models.Cycle,
validators=[
wtforms.validators.InputRequired(),
unique_cycle]),
min_entries=1)
visit_date = DateField(
validators=[
wtforms.validators.InputRequired(),
unique_visit_date])
include_forms = wtforms.BooleanField()
include_specimen = wtforms.BooleanField()
class AttachmentPackageForm(IndicoForm):
added_since = DateField(_('Added Since'), [Optional()], parse_kwargs={'dayfirst': True},
description=_('Include only attachments uploaded after this date'))
filter_type = IndicoRadioField(_('Include'), [DataRequired()])
sessions = IndicoSelectMultipleCheckboxField(_('Sessions'), [HiddenUnless('filter_type', 'sessions'),
DataRequired()],
description=_('Include materials from selected sessions'))
contributions = IndicoSelectMultipleCheckboxField(_('Contributions'),
[HiddenUnless('filter_type', 'contributions'), DataRequired()],
description=_('Include materials from selected contributions'))
dates = IndicoSelectMultipleCheckboxField(_('Events scheduled on'), [HiddenUnless('filter_type', 'dates'),
DataRequired()],
description=_('Include materials from sessions/contributions scheduled '
'on the selected dates'))
class AliquotForm(wtforms.Form):
ui_selected = wtforms.BooleanField()
id = wtforms.IntegerField(widget=wtforms.widgets.HiddenInput())
amount = wtforms.DecimalField(places=1,
validators=[conditionally_required])
store_date = DateField(validators=[conditionally_required])
freezer = wtforms.StringField(
validators=[wtforms.validators.optional()])
rack = wtforms.StringField(validators=[wtforms.validators.optional()])
box = wtforms.StringField(validators=[wtforms.validators.optional()])
special_instruction = wtforms.SelectField(
choices=available_instructions,
coerce=int,
validators=[wtforms.validators.optional()])
notes = wtforms.TextAreaField(
validators=[wtforms.validators.optional()])
class editPostForm(FlaskForm):
published = BooleanField('Published?')
slug = StringField('Slug',
validators=[DataRequired(message='A slug is required')
]) # TODO: Validate Slug
date = DateField('Date',
validators=[DataRequired(message='A date is required')])
description = StringField('Short Description')
category = SelectField('Category', coerce=int) # TODO: Validate this field
tags = StringField(
'Tags', validators=[DataRequired(message='Please add at least 1 tag')])
author = SelectField('Author', coerce=int) # TODO: Validate this field
image = FileField('Update Featured Image',
validators=[
FileAllowed(['png', 'jpg', 'jpeg', 'gif'],
message='That file type is not allowed')
])
class AliquotForm(wtforms.Form):
ui_selected = wtforms.BooleanField()
id = wtforms.IntegerField(widget=wtforms.widgets.HiddenInput())
amount = wtforms.DecimalField(
places=1, validators=[wtforms.validators.required()])
collect_date = DateField(validators=[
wtforms.validators.required(),
DateRange(min=date(1900, 1, 1))
])
collect_time = TimeField(validators=[
wtforms.validators.required(),
])
freezer = wtforms.StringField(
validators=[wtforms.validators.optional()])
rack = wtforms.StringField(validators=[wtforms.validators.optional()])
box = wtforms.StringField(validators=[wtforms.validators.optional()])
notes = wtforms.TextAreaField(
validators=[wtforms.validators.optional()])
class CheckoutForm(wtforms.Form):
location_id = wtforms.SelectField(
_('Lab Location'),
description=_('The location of the aliquot'),
choices=available_locations,
coerce=int,
validators=[wtforms.validators.DataRequired()])
sent_date = DateField(_(u'Sent Date'),
description=_(u'Date sent for analysis.'),
validators=[wtforms.validators.Optional()])
sent_name = wtforms.StringField(
_(u'Sent Name '),
description=_(u'The name of the aliquot\'s receiver.'),
validators=[wtforms.validators.Optional()])
sent_notes = wtforms.TextAreaField(
_(u'Sent Notes '),
description=_(u'Notes about this aliquot\'s destination'),
validators=[wtforms.validators.Optional()])
class createPostForm(FlaskForm):
title = StringField('Title',
validators=[
DataRequired(message='The post must have a title'),
postTitleCheck
])
date = DateField('Date',
validators=[DataRequired(message='A date is required')])
description = StringField('Short Description')
category = SelectField('Category', coerce=int) # TODO: Validate this field
tags = StringField(
'Tags', validators=[DataRequired(message='Please add at least 1 tag')])
image = FileField(
'Featured Image',
validators=[
FileRequired(message='Please provide a featured image'),
FileAllowed(['png', 'jpg', 'jpeg', 'gif'],
message='That file type is not allowed')
])
class AlreadyHaveAFlightForm(Form):
carrier_dict_name, _ = mu.read_carrier_dict()
carriers = ['%s - %s' % (v, k) for k, v in carrier_dict_name.iteritems()]
carrier_values = carrier_dict_name.keys() + carrier_dict_name.values(
) + carriers
carrier_validator = AnyOf(
carrier_values, message=u'Invalid input, must be a carrier name.')
date = DateField('Date', validators=[Required(), date_after_today])
carrier = TextField('Carrier', validators=[Required(), carrier_validator])
flightnumber = IntegerField(
'FlightNumber',
validators=[
Required(
message=u'This field is required, and must be an integer.'),
NumberRange(min=1,
message=u'Invalid input, must be greater than zero.')
])
class StudyForm(Form):
title = wtforms.StringField(validators=[
wtforms.validators.InputRequired(),
wtforms.validators.Length(min=1, max=32), check_unique_url
])
code = wtforms.StringField(validators=[
wtforms.validators.InputRequired(),
wtforms.validators.Length(min=1, max=8)
])
short_title = wtforms.StringField(validators=[
wtforms.validators.InputRequired(),
wtforms.validators.Length(min=1, max=8)
])
consent_date = DateField()
termination_form = ModelField(db_session=db_session,
class_=datastore.Schema,
validators=[
wtforms.validators.Optional(),
check_has_termination_date
])
is_randomized = wtforms.BooleanField()
is_blinded = wtforms.BooleanField()
randomzation_form = ModelField(db_session=db_session,
class_=datastore.Schema)
class HistoryDateForm(Form):
# Due to request context issues, cannot access the user's timezone
default_date = datetime.now(None).today()
start_date = DateField("Start Date", default=default_date)
end_date = DateField("End Date", default=default_date)
class GenerateDowntimeForm(FlaskForm):
scheduled = SelectField(
"Scheduled (registered at least 24 hours in advance)",
[InputRequired()],
choices=[
("", "-- Select one --"),
("SCHEDULED", "Yes"),
("UNSCHEDULED", "No"),
])
severity = SelectField(
"Severity (how much of the resource is affected)", [InputRequired()],
choices=[("", "-- Select one --"),
("Outage", "Outage (completely inaccessible)"),
("Severe", "Severe (most services down)"),
("Intermittent Outage",
"Intermittent Outage (may be up for some of the time)"),
("No Significant Outage Expected",
"No Significant Outage Expected (you shouldn't notice)")])
description = StringField(
"Description (the reason and/or impact of the outage)",
[InputRequired()])
start_date = DateField("Start Date/Time (UTC)", [InputRequired()])
start_time = TimeField(" ", [InputRequired()])
end_date = DateField("End Date/Time (UTC)", [InputRequired()])
end_time = TimeField(" ", [InputRequired()])
services = SelectMultipleField("Known OSG Services (select one or more)",
[InputRequired()],
choices=[])
facility = SelectField("Facility", choices=[])
change_facility = SubmitField()
resource = SelectField("Resource", choices=[])
change_resource = SubmitField()
generate = SubmitField()
yamloutput = TextAreaField(None,
render_kw={
"readonly": True,
"style":
"font-family:monospace; font-size:small;",
"rows": "15"
})
class Meta:
csrf = False # CSRF not needed because no data gets modified
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.infos = ""
# https://stackoverflow.com/a/21815180
def validate(self):
self.infos = ""
if not super().validate():
return False
if self.start_date.data > self.end_date.data:
self.end_date.errors.append(
"End date/time must be after start date/time")
return False
elif self.start_date.data == self.end_date.data:
if self.start_time.data >= self.end_time.data:
self.end_time.errors.append(
"End date/time must be after start date/time")
return False
days_in_future = (self.get_start_datetime() -
datetime.datetime.utcnow()).days
if days_in_future < 1 and self.scheduled.data == "SCHEDULED":
self.infos += "Note: Downtime registered less than one day in advance " \
"is considered unscheduled by WLCG policy."
elif days_in_future >= 1 and self.scheduled.data == "UNSCHEDULED":
self.infos += "Note: Downtime registered at least one day in advance " \
"is considered scheduled by WLCG policy."
return True
def get_start_datetime(self):
return datetime.datetime.combine(self.start_date.data,
self.start_time.data)
def get_end_datetime(self):
return datetime.datetime.combine(self.end_date.data,
self.end_time.data)
def get_yaml(self) -> str:
created_datetime = datetime.datetime.utcnow()
dtid = models._dtid(created_datetime)
return models.get_downtime_yaml(
id=dtid,
start_datetime=self.get_start_datetime(),
end_datetime=self.get_end_datetime(),
created_datetime=created_datetime,
description=self.description.data,
severity=self.severity.data,
class_=self.scheduled.data,
resource_name=self.resource.data,
services=self.services.data,
)
class CardUnblockForm(Form):
unblocked_at = DateField(u'Unblocked date',
display_format="%m/%d/%Y",
validators=[validators.required()])
class CardBlockForm(Form):
reason = TextField(u'Reason', validators=[validators.required()])
blocked_at = DateField(u'Blocked starting',
display_format="%m/%d/%Y",
validators=[validators.required()])
class ReminderForm(IndicoForm):
default_widget_attrs = {'absolute_time': {'placeholder': 'HH:MM'}}
recipient_fields = {'recipients', 'send_to_participants'}
schedule_fields = {
'schedule_type', 'absolute_date', 'absolute_time', 'relative_delta'
}
schedule_recipient_fields = recipient_fields | schedule_fields
# Schedule
schedule_type = IndicoRadioField(
_('Type'), [DataRequired()],
choices=[('relative', _("Relative to the event start time")),
('absolute', _("Fixed date/time")),
('now', _('Send immediately'))])
relative_delta = TimeDeltaField(
_('Offset'),
[HiddenUnless('schedule_type', 'relative'),
DataRequired()])
absolute_date = DateField(
_('Date'), [HiddenUnless('schedule_type', 'absolute'),
DataRequired()],
parse_kwargs={'dayfirst': True})
absolute_time = TimeField(
_('Time'),
[HiddenUnless('schedule_type', 'absolute'),
InputRequired()])
# Recipients
recipients = EmailListField(_('Email addresses'),
description=_('One email address per line.'))
send_to_participants = BooleanField(
_('Participants'),
description=_('Send the reminder to all participants/registrants '
'of the event.'))
# Misc
reply_to_address = SelectField(
_('Sender'), [DataRequired()],
description=_('The email address that will show up as the sender.'))
message = TextAreaField(
_('Note'), description=_('A custom message to include in the email.'))
include_summary = BooleanField(
_('Include agenda'),
description=_(
"Includes a simple text version of the event's agenda in the email."
))
def __init__(self, *args, **kwargs):
self.event = kwargs.pop('event')
super(ReminderForm, self).__init__(*args, **kwargs)
self.absolute_time.description = _(
'Your active timezone is {tz}.').format(tz=self.timezone)
self._set_email_choices()
if self.event.getType() == 'simple_event':
del self.include_summary
def _set_email_choices(self):
# User
emails = {session.user.email: session.user.full_name}
# Creator
emails[self.event.as_event.creator.
email] = self.event.as_event.creator.full_name
# Support
support = self.event.getSupportInfo()
emails[support.getEmail()] = support.getCaption() or support.getEmail()
# Chairs
emails.update((pl.email, pl.full_name)
for pl in self.event.as_event.person_links if pl.email)
# Current email to avoid destructive modifications
emails.setdefault(self.reply_to_address.object_data,
self.reply_to_address.object_data)
# Sanitize and format emails
emails = {
to_unicode(email.strip().lower()):
'{} <{}>'.format(to_unicode(name), to_unicode(email))
for email, name in emails.iteritems() if email and email.strip()
}
self.reply_to_address.choices = sorted(
emails.items(),
key=lambda x: (x[0] != session.user.email, x[1].lower()))
def validate_recipients(self, field):
if not field.data and not self.send_to_participants.data:
raise ValidationError(
_('If participants are not included you need to specify recipients.'
))
def validate_send_to_participants(self, field):
if not field.data and not self.recipients.data:
raise ValidationError(
_('If no recipients are specified you need to include participants.'
))
def validate_schedule_type(self, field):
# Be graceful and allow a reminder that's in the past but on the same day.
# It will be sent immediately but that way we are a little bit more user-friendly
if field.data == 'now':
return
scheduled_dt = self.scheduled_dt.data
if scheduled_dt is not None and scheduled_dt.date() < now_utc().date():
raise ValidationError(_('The specified date is in the past'))
def validate_absolute_date(self, field):
if self.schedule_type.data == 'absolute' and field.data < date.today():
raise ValidationError(_('The specified date is in the past'))
@property
def timezone(self):
return DisplayTZ(conf=self.event).getDisplayTZ()
@generated_data
def scheduled_dt(self):
if self.schedule_type.data == 'absolute':
if self.absolute_date.data is None or self.absolute_time.data is None:
return None
dt = datetime.combine(self.absolute_date.data,
self.absolute_time.data)
return get_timezone(self.timezone).localize(dt).astimezone(
pytz.utc)
elif self.schedule_type.data == 'relative':
if self.relative_delta.data is None:
return None
return self.event.getStartDate() - self.relative_delta.data
elif self.schedule_type.data == 'now':
return now_utc()
@generated_data
def event_start_delta(self):
return self.relative_delta.data if self.schedule_type.data == 'relative' else None
class AssebledChartForm(Form):
date_from = DateField('From', widget=DatePickerWidget())
date_to = DateField('To', widget=DatePickerWidget())
submit = SubmitField('Submit')
class TaskForm(Form):
name = TextField('name', validators=[Length(max=20), Required()])
description = TextField('description')
end = DateField('end', validators=[Required()])
class AccountDobSetForm(Form):
dob = DateField('Date of birth (yyyy-mm-dd)', [validators.Required()])
class ReminderForm(IndicoForm):
default_widget_attrs = {'absolute_time': {'placeholder': 'HH:MM'}}
recipient_fields = {'recipients', 'send_to_participants'}
schedule_fields = {
'schedule_type', 'absolute_date', 'absolute_time', 'relative_delta'
}
schedule_recipient_fields = recipient_fields | schedule_fields
# Schedule
schedule_type = IndicoRadioField(
_('Type'), [DataRequired()],
choices=[('relative', _("Relative to the event start time")),
('absolute', _("Fixed date/time")),
('now', _('Send immediately'))])
relative_delta = TimeDeltaField(
_('Offset'),
[HiddenUnless('schedule_type', 'relative'),
DataRequired()])
absolute_date = DateField(
_('Date'), [HiddenUnless('schedule_type', 'absolute'),
DataRequired()],
parse_kwargs={'dayfirst': True})
absolute_time = TimeField(
_('Time'),
[HiddenUnless('schedule_type', 'absolute'),
InputRequired()])
# Recipients
recipients = EmailListField(_('Email addresses'),
description=_('One email address per line.'))
send_to_participants = BooleanField(
_('Participants'),
description=_('Send the reminder to all participants/registrants '
'of the event.'))
# Misc
reply_to_address = SelectField(
_('Sender'), [DataRequired()],
description=_('The email address that will show up as the sender.'))
message = TextAreaField(
_('Note'), description=_('A custom message to include in the email.'))
include_summary = BooleanField(
_('Include agenda'),
description=_(
"Includes a simple text version of the event's agenda in the email."
))
def __init__(self, *args, **kwargs):
self.event = kwargs.pop('event')
super(ReminderForm, self).__init__(*args, **kwargs)
self.absolute_time.description = _(
"The event's timezone is {tz}.").format(tz=self.event.tzinfo)
self.reply_to_address.choices = (self.event.get_allowed_sender_emails(
extra=self.reply_to_address.object_data).items())
if self.event.type_ == EventType.lecture:
del self.include_summary
def validate_recipients(self, field):
if not field.data and not self.send_to_participants.data:
raise ValidationError(
_('If participants are not included you need to specify recipients.'
))
def validate_send_to_participants(self, field):
if not field.data and not self.recipients.data:
raise ValidationError(
_('If no recipients are specified you need to include participants.'
))
def validate_schedule_type(self, field):
# Be graceful and allow a reminder that's in the past but on the same day.
# It will be sent immediately but that way we are a little bit more user-friendly
if field.data == 'now':
return
scheduled_dt = self.scheduled_dt.data
if scheduled_dt is not None and scheduled_dt.date() < now_utc().date():
raise ValidationError(_('The specified date is in the past'))
def validate_absolute_date(self, field):
if self.schedule_type.data == 'absolute' and field.data < date.today():
raise ValidationError(_('The specified date is in the past'))
@generated_data
def scheduled_dt(self):
if self.schedule_type.data == 'absolute':
if self.absolute_date.data is None or self.absolute_time.data is None:
return None
dt = datetime.combine(self.absolute_date.data,
self.absolute_time.data)
return self.event.tzinfo.localize(dt).astimezone(pytz.utc)
elif self.schedule_type.data == 'relative':
if self.relative_delta.data is None:
return None
return self.event.start_dt - self.relative_delta.data
elif self.schedule_type.data == 'now':
return now_utc()
@generated_data
def event_start_delta(self):
return self.relative_delta.data if self.schedule_type.data == 'relative' else None
class ReviewForm(FlaskForm):
"""Form to submit review.
Fields:
name (str): disabled (display only). Name of business being reviewed
id (int): hidden, id of business being reviewed
category (select): category for service/business being reviewed
rating (radio): Numeric rating of 1 to 5 for total quality
cost (radio): Numeric rating of 1 to 5 based on perceived cost
description (str): Optional, short description of service provided or
business interraction
service_date (Date): Optional, date of service or interraction w/
business
comments (text): Optional, longer description/commentary of review
picture (File): Optional, add pictures to review
Methods:
validate_name: checks that submitted id and name match
validate_category: checks that review category is category of the
business
"""
name = StringField(
"Provider / Business Name",
render_kw={'readonly': True},
validators=[InputRequired(message="Business name is required.")])
id = HiddenField(
"Provider Value",
render_kw={'readonly': True},
validators=[
InputRequired(
message="Business id is required. Do not remove from form "
"submission.")
])
category = SelectField(
"Category",
choices=[],
validators=[InputRequired(message="Category is required.")],
coerce=int,
id="category")
rating = RadioField(
"Overall Rating",
choices=[(5, "***** (Highest quality)"), (4, "**** (Above Average)"),
(3, "*** (Satisfied - should be default choice"),
(2, "** (Below Average)"), (1, "* (Stay away from!)")],
coerce=int,
validators=[InputRequired(message="Rating is required.")])
cost = RadioField("Cost- rating",
choices=[(5, "$$$$$ (Much higher than competitors)"),
(4, "$$$$ (Above Average)"),
(3, "$$$ (Average / should be default choice"),
(2, "$$ (Below Average)"),
(1, "$ (Significantly less than competitors)")],
coerce=int,
validators=[InputRequired(message="Cost is required.")])
price_paid = StringField("Price Paid",
filters=(dollar_filter, int_filter),
validators=[Optional()])
description = StringField("Service Description", validators=[Optional()])
service_date = DateField("Service Date",
validators=[validate_date,
Optional()])
comments = TextAreaField("Comments",
render_kw={"rows": 6},
validators=[Optional()])
picture = MultipleFileField("Picture",
render_kw=({
"accept": 'image/*'
}),
validators=[Picture_Upload_Check,
Optional()])
certify = BooleanField(
"Reviewer confirms that they have neither received compensation for "
"review nor are related (relative, employee) to business being "
"reviewed.",
validators=[
InputRequired(
"Review unable to be submitted unless reviewer confirms "
"agreement.")
])
submit = SubmitField("Submit", id="review_submit")
def validate_name(self, name):
"""Validates name field as well as id hidden field."""
provider = Provider.query.get(self.id.data)
if provider is None:
pass
elif provider.name != name.data:
raise ValidationError(
"Submitted name and id combination are invalid.")
def validate_category(self, category):
"""Checks that category is valid category for provider."""
id = self.id.data
if id is None or id == "":
pass
else:
bizCategories = [c.id for c in Provider.query.get(id).categories]
if category.data not in bizCategories:
raise ValidationError(
"Category not valid for business being reviewed.")
def validate_price_paid(self, price_paid):
if price_paid.data is not None and price_paid.data != '':
price_paid_num = int(price_paid.data)
if price_paid_num < 0:
raise ValidationError("Dollar cost must be greater than 0.")
class F(Form):
a = DateTimeField()
b = DateField(default=lambda: date(2004, 9, 12))
c = DateField(parse_kwargs=dict(yearfirst=True, dayfirst=False))
class GoalForm(Form):
name = TextField('name', validators=[Required()])
description = TextField('description')
end = DateField('end', validators=[Required()])
people = TagListField('people',
validators=[validUserCheck, emptinessCheck])