class BookingSearchForm(IndicoForm):
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 Videoconference'))
needs_vc_assistance = BooleanField(_('Videoconference Setup Assistance'))
needs_assistance = BooleanField('General Assistance')
@generated_data
def start_dt(self):
return datetime.combine(self.start_date.data, self.start_time.data)
@generated_data
def end_dt(self):
return datetime.combine(self.end_date.data, self.end_time.data)
class CardForm(Form):
key = TextField(u'JIRA Key', validators=[validators.required()])
title = TextField(u'Card title', validators=[validators.required()])
team = SelectField(u'Team',
choices=TEAM_CHOICES,
validators=[validators.required()])
state = SelectField(u'State',
choices=STATE_CHOICES,
validators=[validators.required()])
backlog_date = DateField(u'Backlog date',
display_format="%m/%d/%Y",
validators=[validators.required()])
start_date = DateField(u'Start date',
display_format="%m/%d/%Y",
validators=[
start_date_validator,
])
done_date = DateField(u'Done date',
display_format="%m/%d/%Y",
validators=[
done_date_validator,
])
priority = IntegerField(u'Ordering', validators=[validators.optional()])
def populate_obj(self, obj):
super(CardForm, self).populate_obj(obj)
if self.data['priority'] == u"":
obj.priority = None
class SearchForm(IndicoForm):
phrase = StringField(_('Phrase'))
field = SelectField(_('Search in'), choices=FIELD_CHOICES, default='')
start_date = DateField('Start Date', [Optional()],
parse_kwargs={'dayfirst': True})
end_date = DateField('End Date', [Optional()],
parse_kwargs={'dayfirst': True})
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 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()])
to = DateField(_(u'To Date'),
validators=[wtforms.validators.Optional()])
class FilterForm(Form):
page = wtforms.IntegerField()
status = wtforms.StringField(validators=[
wtforms.validators.Optional(),
wtforms.validators.AnyOf(statuses)
])
start = DateField()
end = DateField()
class CreateBlockingForm(BlockingForm):
start_date = DateField(_(u'Start date'), [DataRequired()], parse_kwargs={'dayfirst': True})
end_date = DateField(_(u'End date'), [DataRequired()], parse_kwargs={'dayfirst': True})
def validate_start_date(self, field):
if self.start_date.data > self.end_date.data:
raise ValidationError('Blocking may not end before it starts!')
validate_end_date = validate_start_date
class SearchForm(IndicoForm):
phrase = StringField(_('Phrase'))
field = SelectField(_('Search in'), choices=FIELD_CHOICES, default='')
start_date = DateField('Start Date', [Optional()],
parse_kwargs={'dayfirst': True})
end_date = DateField('End Date', [Optional()],
parse_kwargs={'dayfirst': True})
def is_submitted(self):
return 'search-phrase' in request.args
class MgrContribApplicationForm(ContribApplicationForm):
"""Form handling the management of a contributing application"""
manager = SelectField("Manager", coerce=int)
manager_date = DateField('Date Assigned',
validators=[Optional()],
display_format='%Y-%m-%d')
comment = TextAreaField('Mgr Comments')
approve = SelectField('Approved',
choices=[('1', 'Yes'), ('0', 'No'), ('None', '---')])
approve_date = DateField('Date Approved',
validators=[Optional()],
display_format='%Y-%m-%d')
class SpecimenForm(wtforms.Form):
ui_selected = wtforms.BooleanField()
id = wtforms.IntegerField(widget=wtforms.widgets.HiddenInput())
tubes = wtforms.IntegerField(
validators=[
wtforms.validators.input_required(),
wtforms.validators.NumberRange(min=1)])
collect_date = DateField(
validators=[
conditionally_required,
DateRange(min=date(1900, 1, 1))
])
collect_time = TimeField(
# There doesn't seem to be a nice way to add the colon if the
# user forgets to do so, might need to make our own Field type
format='%H:%M',
validators=[conditionally_required])
location_id = wtforms.SelectField(
choices=locations,
coerce=int,
validators=[conditionally_required])
notes = wtforms.TextAreaField(
validators=[wtforms.validators.optional()])
class TransactionForm(Form):
holding_id = SelectField(
'Holding', description='Commodity holding', coerce=int)
type_id = SelectField(
'Type', description='Type of transaction', coerce=int)
shares = FloatField(
'Shares', description='Number of shares', validators=univals)
price = FloatField(
'Share Price', description='Price per share', validators=univals)
date = DateField(
'Date', description='Date the event happened', validators=univals)
commissionable = BooleanField(
'Commissionable', description='Were commissions paid?')
@classmethod
def new(self):
form = self()
helper = help()
tables = ['holding', 'commodity']
fields = ['id', 'symbol']
form.holding_id.choices = helper.get_x_choices(tables, fields)
form.holding_id.validators = helper.get_validators('holding', 'id')
form.type_id.choices = helper.get_choices('trxn_type', 'id', 'name')
form.type_id.validators = helper.get_validators('holding', 'id')
return form
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(validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1)),
])
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 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'),
coerce=int)
contributions = IndicoSelectMultipleCheckboxField(
_('Contributions'),
[HiddenUnless('filter_type', 'contributions'),
DataRequired()],
description=_('Include materials from selected contributions'),
coerce=int)
dates = IndicoSelectMultipleCheckboxField(
_('Events scheduled on'),
[HiddenUnless('filter_type', 'dates'),
DataRequired()],
description=_(
'Include materials from sessions/contributions scheduled '
'on the selected dates'))
class AccountCreateForm(Form):
first_name = StringField(
'First name', [validators.Required(),
validators.Length(max=64)])
last_name = StringField('Last name',
[validators.Required(),
validators.Length(max=64)])
email = EmailField(
'Email',
[validators.Required(),
validators.Email(),
validators.Length(max=64)])
password = PasswordField('Password', [
validators.Required(),
validators.Length(min=5, max=92),
validators.EqualTo('confirm', message='Passwords must match!')
])
confirm = PasswordField('Confirm password')
street_address = StringField(
'Street address', [validators.Required(),
validators.Length(max=128)])
city = StringField('City',
[validators.Required(),
validators.Length(max=64)])
state = StringField(
'State', [validators.Required(),
validators.Length(min=2, max=2)])
postal_code = StringField(
'ZIP code', [validators.Required(),
validators.Regexp(r'\d{5}')])
dob = DateField('Date of birth (yyyy-mm-dd)', [validators.Required()])
class PriceForm(Form):
commodity_id = SelectField('Stock', description='Stock', coerce=int)
currency_id = SelectField('Currency',
description='Currency the price is in',
coerce=int)
close = FloatField('Closing Price',
description='End of day closing price',
validators=univals)
date = DateField('Date', description='Closing date', validators=univals)
@classmethod
def new(self):
form = self()
helper = help()
table = 'commodity'
args = [table, 'id']
kwargs = {'order': 'symbol', 'name': 'type_id', 'val': range(5)}
form.commodity_id.choices = helper.get_choices(*args, **kwargs)
form.commodity_id.validators = helper.get_validators(*args)
kwargs.update({'val': [5]})
form.currency_id.choices = helper.get_choices(*args, **kwargs)
form.currency_id.validators = helper.get_validators(*args)
return form
class AddForm(Form):
schema = ModelField(
db_session=db_session,
class_=datastore.Schema,
validators=[wtforms.validators.InputRequired(), check_study_form])
collect_date = DateField(
validators=[wtforms.validators.InputRequired()])
class EventForm(Form):
type_id = SelectField('Event Type',
description='Type of event',
coerce=int)
commodity_id = SelectField('Stock', description='Stock', coerce=int)
currency_id = SelectField('Currency',
description='Unit the event is measured in',
coerce=int)
value = FloatField('Value',
description='Amount the event was worth',
validators=univals)
date = DateField('Date',
description='Date the event happened',
validators=univals)
@classmethod
def new(self):
form = self()
helper = help()
table = 'commodity'
args = [table, 'id']
kwargs = {'order': 'symbol', 'name': 'type_id', 'val': range(5)}
form.commodity_id.choices = helper.get_choices(*args, **kwargs)
form.commodity_id.validators = helper.get_validators(*args)
form.type_id.choices = helper.get_choices('event_type', 'id', 'name')
form.type_id.validators = helper.get_validators('event_type', 'id')
kwargs.update({'val': [5, 6]})
form.currency_id.choices = helper.get_choices(*args, **kwargs)
form.currency_id.validators = helper.get_validators(*args)
return form
class LoginForm(Form):
"""Accepts a nickname and a room."""
name = StringField('Observer', validators=[Required()])
date = DateField('Date (UTC)',
validators=[Required()],
display_format='%Y-%m-%d')
room = StringField('Room', validators=[Optional()])
submit_start = SubmitField('Start of Night Form')
submit_end = SubmitField('End of Night Form')
def event_edit(oid, enumber):
olymp = OlympiadCategory.objects.get_or_404(id=oid)
event = olymp.events[enumber - 1]
OlympiadForm = model_form(Olympiad)
OlympiadForm.start_date = DateField()
OlympiadForm.end_date = DateField()
form = OlympiadForm(request.form, obj=event, csrf_enabled=False)
form.start_date.widget.input_type = 'date'
form.end_date.widget.input_type = 'date'
if form.validate_on_submit():
return 'done!'
return render_template('admin/olympiad_new.html',
category=olymp,
form=form)
class UpdateTokenForm(FlaskForm):
tokens = StringField('Token')
token_amount = FloatField('Amount',
validators=[DataRequired(),
NumberRange(min=0)])
token_price = FloatField('Price', validators=[DataRequired()])
buy_date = DateField('Date',
display_format='%Y-%m-%d',
validators=[DataRequired()])
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(),
DateRange(min=date(1900, 1, 1))
])
to = DateField(_(u'To Date'),
validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1))
])
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 EpisodeForm(FlaskForm):
date = DateField('Date')
patient_id = SelectField('Patient')
hospital_id = SelectField('Hospital')
surgery_id = HiddenField('Surgery')
comments = TextAreaField('Comments')
created_by = HiddenField('Created By')
created_at = HiddenField('Created At')
updated_by = HiddenField('Updated By')
updated_at = HiddenField('Updated At')
def create_event(oid):
OlympiadForm = model_form(Olympiad)
OlympiadForm.start_date = DateField()
OlympiadForm.end_date = DateField()
form = OlympiadForm(request.form, csrf_enabled=False)
form.start_date.widget.input_type = 'date'
form.end_date.widget.input_type = 'date'
if form.validate_on_submit():
category = OlympiadCategory.objects.get_or_404(id=oid)
new_event = Olympiad()
form.populate_obj(new_event)
category.events.append(new_event)
category.save()
url = request.form['callback_url']
return redirect(url)
category = OlympiadCategory.objects.get_or_404(id=oid)
return render_template('admin/olympiad_new.html',
category=category,
form=form)
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(),
DateRange(min=date(1900, 1, 1)), unique_visit_date
])
include_forms = wtforms.BooleanField()
include_specimen = wtforms.BooleanField()
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()])
sent_name = wtforms.StringField(
validators=[wtforms.validators.Optional()])
sent_notes = wtforms.TextAreaField(
validators=[wtforms.validators.Optional()])
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 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 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 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()])
