class SignupForm(Form):
business_name = fields.TextField(validators=[DataRequired()])
email = fields.TextField(validators=[DataRequired(), Email()])
first_name = fields.TextField()
last_name = fields.TextField()
phone_number = fields.TextField(validators=[validate_phone_number])
fax_number = fields.TextField(validators=[validate_phone_number])
woman_owned = fields.BooleanField('Woman-owned business')
minority_owned = fields.BooleanField('Minority-owned business')
veteran_owned = fields.BooleanField('Veteran-owned business')
disadvantaged_owned = fields.BooleanField(
'Disadvantaged business enterprise')
categories = fields.SelectField()
subcategories = MultiCheckboxField(coerce=int)
def validate_subcategories(form, field):
if field.data:
if len(field.data) == 0:
raise ValidationError('You must select at least one category!')
for val in field.data:
_cat = Category.query.get(val)
if _cat is None:
raise ValidationError(
'{} is not a valid choice!'.format(val))
def convert(self, model, field, field_args, multiple=False):
kwargs = {
'label': unicode(field.verbose_name or field.name or ''),
'description': field.help_text or '',
'validators': [],
'filters': [],
'default': field.default,
}
if field_args:
kwargs.update(field_args)
if field.required:
# Hacky but necessary, since validators.Required doesn't handle 0 properly
if isinstance(field, IntField):
kwargs['validators'].append(validators.InputRequired())
else:
kwargs['validators'].append(validators.Required())
else:
kwargs['validators'].append(validators.Optional())
if field.choices:
kwargs['choices'] = field.choices
if isinstance(field, IntField):
kwargs['coerce'] = int
if not multiple:
return f.SelectField(**kwargs)
else:
return f.SelectMultipleField(**kwargs)
ftype = type(field).__name__
if hasattr(field, 'to_form_field'):
return field.to_form_field(model, kwargs)
if ftype in self.converters:
return self.converters[ftype](model, field, kwargs)
class CreateAdminForm(Form):
username = f.StringField("用户名",
validators=[
validators.DataRequired(message="不能为空"),
validators.Length(3, 32)
])
password = f.PasswordField("密码",
validators=[
validators.DataRequired(message="不能为空"),
validators.Length(5, 32)
])
name = f.StringField("名字",
validators=[validators.DataRequired(message="不能为空")])
mobile = f.StringField("手机", validators=[validators.Optional()])
email = f.StringField(
"电子邮箱",
validators=[validators.Optional(),
validators.Email(message="格式不正确")])
is_super = f.BooleanField("超级管理员")
roles = f.SelectMultipleField("权限", choices=Admin.ROLES)
state = f.SelectField("是否启用", choices=[
("1", "启用"),
("0", "禁用"),
])
manage_provinces = f.SelectMultipleField("管辖省份",
choices=ChinaCity.get_provinces())
def validate_username(self, field):
if Admin.select().where(Admin.username == field.data).count() > 0:
raise ValidationError('用户名已存在')
def validate_mobile(self, field):
if not is_mobile(field.data):
raise ValidationError('手机号码格式不正确')
class ContestSubmitForm(Form):
contest_problem_id = fields.IntegerField(
'Contest_Problem ID', validators=[validators.Required()])
language = fields.SelectField(
'Language',
choices=app.config['PROGRAM_LANGUAGE'].items(),
validators=[validators.Required()])
code = fields.TextAreaField(
'Source Code',
validators=[validators.Optional(),
validators.Length(3, 100000)])
submit = fields.SubmitField('Submit')
def validate_contest_problem_id(self, field):
contest_problem_id = field.data
contest_problem = ContestProblemModel.query.get(contest_problem_id)
if not contest_problem:
raise ValidationError('题目不存在')
if contest_problem.contest.is_hidden:
raise ValidationError('比赛不存在')
if contest_problem.contest.status == 'pending':
raise ValidationError('比赛还没开始')
if contest_problem.contest.status == 'ended':
raise ValidationError('比赛已经结束')
class SettingsForm(FlaskForm):
name = StringField(lazy_gettext('Site Name'))
description = StringField(lazy_gettext('Site Description'))
avatar = StringField(lazy_gettext('Avatar URL'))
cover_url = StringField(lazy_gettext('Cover Image URL'))
locale = fields.SelectField(lazy_gettext('Language'),
choices=[('en', lazy_gettext('English')),
('zh_Hans_CN',
lazy_gettext('Chinese'))],
default='en')
google_site_verification = StringField(
lazy_gettext('Google Site Verification Code'))
disqus_shortname = StringField(lazy_gettext('Disqus Shortname'))
sociallinks = fields.FieldList(fields.FormField(SocialLink),
lazy_gettext('Social Links'),
min_entries=1)
icp = StringField(lazy_gettext('ICP No.'))
links = fields.FieldList(fields.FormField(FriendLink),
lazy_gettext('Friend Links'),
min_entries=1)
@classmethod
def from_local(cls):
return cls(data=g.site)
class JoinForm(BaseForm):
category = fields.SelectField(_('Category'), choices=utils.CATEGORY)
sub_category = fields.SelectField(_('Sub_Category'),
choices=utils.SUBCATEGORY)
min_number_of_people_to_join = fields.SelectField(
_('min_number_of_people_to_join'), choices=utils.NUMBER_OF_PEOPLE_MIN)
max_number_of_people_to_join = fields.SelectField(
_('max_number_of_people_to_join'), choices=utils.NUMBER_OF_PEOPLE_MAX)
duration = fields.SelectField(_('Time_Chunks'), choices=utils.TIME_CHUNKS)
expiration = fields.SelectField(_('Time_Chunks2'),
choices=utils.TIME_CHUNKS2)
#note = fields.TextField(_('note'), [validators.Required(), validators.Length(max=FIELD_MAXLENGTH_NOTE)])
meeting_place = fields.TextField(
_('meeting_place'),
[validators.Required(),
validators.Length(max=FIELD_MAXLENGTH_NOTE)])
activity_location = fields.TextField(
_('activity_location'),
[validators.Required(),
validators.Length(max=FIELD_MAXLENGTH_NOTE)])
message = fields.TextAreaField(
_('Message'), [validators.Required(),
validators.Length(max=65536)])
set_time = fields.TextField(_('set_time'))
class InviteActivateForm(PasswordMixin, PasswordConfirmMixin):
name = fields.TextField(_('Name'), [validators.Length(max=FIELD_MAXLENGTH)])
last_name = fields.TextField(_('Last Name'), [validators.Length(max=FIELD_MAXLENGTH)])
country = fields.SelectField(_('Country'), choices=[])
pass
class RegisterForm(PasswordConfirmMixin, UsernameMixin, NameMixin, EmailMixin):
country = fields.SelectField(_('Country'), choices=[])
tz = fields.SelectField(_('Timezone'), choices=[])
pass
class BaseTemplateForm(Form):
template = fields.SelectField('base template',validators=[validators.InputRequired()])#,choices=[('a','a'),('b','b'),('c','c')])
def conv_Enum(self, column, field_args, **extra):
field_args['choices'] = [(e, e) for e in column.type.enums]
return wtforms_fields.SelectField(**field_args)
class UserOrderForm(form.Form):
order_id = fields.IntegerField(u'订单ID', [validators.InputRequired()])
status = fields.SelectField(u'状态', [validators.InputRequired()], coerce=int,
choices=store.STATUS)
class GiftForm(form.Form):
product_id = fields.SelectField(u'物品ID', [validators.InputRequired()], coerce=int)
credit_type = fields.SelectField(u'价格类型', [validators.InputRequired()], coerce=int,
choices=CREDIT_TYPE)
credit_value = fields.IntegerField(u'价格数值', [validators.InputRequired()])
on_sale = fields.BooleanField(u'是否在售', default=True)
class BlogArticleForm(BaseForm):
title = fields.TextField('Article_Title', [validators.Required(), validators.Length(max=50)], id='title')
summary = fields.TextField('Article_Summary', [validators.Required(), validators.Length(max=140)], id='summary')
filename = fields.TextField('Article_Filename', [validators.Required(), validators.Length(max=140)], id='filename')
article_type = fields.SelectField('Article Type', [validators.Required()], id='type', choices=[('post', 'Blog Post'), ('page', 'Page Content'), ('partial', 'Partial Content')])
class ImageForm(BaseForm):
name = fields.TextField('Name', [validators.Required(), validators.Length(max=50)])
description = fields.TextField('Description', [validators.Required(), validators.Length(max=100)])
url = fields.TextField('Source URL', [validators.Required(), validators.Length(max=250)])
disk_format = fields.SelectField('Disk Format', choices=utils.DISKFORMATS)
container_format = fields.SelectField('Container Format', choices=utils.CONTAINERFORMATS)
class ApplianceForm(BaseForm):
name = fields.TextField('Name', [validators.Required(), validators.Length(max=50)])
token = fields.TextField('Token', [validators.Required(), validators.Length(max=64)])
group = fields.SelectField('Group')
custom = fields.HiddenField('Custom')
class F(Form):
a = fields.TextField('I r label')
b = fields.SelectField(choices=[('a', 'hi'), ('b', 'bai')])
class DomDivForm(FlaskForm):
# Expansions
choices = domdiv.main.EXPANSION_CHOICES
# make pretty names for the expansion choices
choiceNames = []
replacements = {
"1stedition": "1st Edition",
"2ndeditionupgrade": "2nd Edition Upgrade",
"2ndedition": "2nd Edition",
}
for choice in choices:
for s, r in replacements.items():
if choice.lower().endswith(s):
choiceNames.append("{} {}".format(
choice[:-len(s)].capitalize(), r))
break
else:
choiceNames.append(choice.capitalize())
expansions = wtf_fields.SelectMultipleField(
label="Expansions to Include (Cmd/Ctrl click to select multiple)",
choices=list(zip(choices, choiceNames)),
default=["dominion2ndEdition"],
)
# Now Fan expansions
choices = domdiv.main.FAN_CHOICES
# make pretty names for the expansion choices
choiceNames = []
for choice in choices:
for s, r in replacements.items():
if choice.lower().endswith(s):
choiceNames.append("{} {}".format(
choice[:-len(s)].capitalize(), r))
break
else:
choiceNames.append(choice.capitalize())
fan = wtf_fields.SelectMultipleField(
choices=list(zip(choices, choiceNames)),
label="Fan Expansions to Include (Cmd/Ctrl click to select multiple)",
)
orientation = wtf_fields.SelectField(
label="Divider Orientation",
choices=[("horizontal", "Horizontal"), ("vertical", "Vertical")],
default="horizontal",
)
pagesize = wtf_fields.SelectField(
label="Paper Size",
choices=list(
zip(
PAPER_SIZES + domdiv.main.LABEL_KEYS,
PAPER_SIZES + domdiv.main.LABEL_SELECTIONS,
)),
default="Letter",
)
choices = ["Sleeved - Thin", "Sleeved - Thick", "Unsleeved"]
cardsize = wtf_fields.SelectField(choices=list(zip(choices, choices)),
label="Card Size",
default="Unsleeved")
tabwidth = wtf_fields.FloatField(
label="Width of Tab in centimeters",
default=4.0,
)
back_offset = wtf_fields.FloatField(
label="Back page horizontal offset points to shift to the right",
default=0,
)
back_offset_height = wtf_fields.FloatField(
label="Back page vertical offset points to shift upward",
default=0,
)
horizontal_gap = wtf_fields.FloatField(
label="Horizontal gap between dividers in centimeters",
default=0,
)
vertical_gap = wtf_fields.FloatField(
label="Vertical gap between dividers in centimeters",
default=0,
)
black_tabs = wtf_fields.BooleanField(label="Black tab background", )
tabwidth = wtf_fields.FloatField(label="Width of Tab in centimeters",
default=4.0)
base_cards_with_expansion = wtf_fields.BooleanField(
label="Include Base cards with the expansion", default=False)
upgrade_with_expansion = wtf_fields.BooleanField(
label="Include upgrade cards with the expansion being upgraded",
default=False)
edition = wtf_fields.SelectField(
choices=list(
zip(domdiv.main.EDITION_CHOICES, domdiv.main.EDITION_CHOICES)),
label="Edition",
default="all",
)
cropmarks = wtf_fields.BooleanField(label="Cropmarks Instead of Outlines",
default=False)
linetype = wtf_fields.SelectField(
choices=list(zip(domdiv.main.LINE_CHOICES, domdiv.main.LINE_CHOICES)),
label="Outline Type",
default="line",
)
wrapper = wtf_fields.BooleanField(label="Slipcases Instead of Dividers",
default=False)
notch = wtf_fields.BooleanField(
label="If Slipcases, add a notch in corners", default=False)
tab_serpentine = wtf_fields.BooleanField(
label=
"For 3 or more tabs, tab location reverses when the end is reached instead of resetting to the start",
default=False,
)
expansion_reset_tabs = wtf_fields.BooleanField(
label="Restart tab starting location with every expansion.",
default=True)
count = wtf_fields.BooleanField(label="Show number of Cards per Divider",
default=False)
types = wtf_fields.BooleanField(label="Show Card Type on each Divider",
default=False)
tab_name_align = wtf_fields.SelectField(
choices=list(
zip(domdiv.main.NAME_ALIGN_CHOICES,
domdiv.main.NAME_ALIGN_CHOICES)),
default=domdiv.main.NAME_ALIGN_CHOICES[0],
)
tab_number = wtf_fields.SelectField(choices=list(
TAB_NUMBER_SELECTION.items()),
label="Number of tabs",
default=1)
for x in domdiv.main.TAB_SIDE_CHOICES:
if x not in TAB_SIDE_SELECTION:
TAB_SIDE_SELECTION[x] = x.title()
tab_side = wtf_fields.SelectField(
choices=list(TAB_SIDE_SELECTION.items()),
label="Starting tab location",
default="left",
)
order = wtf_fields.SelectField(
label="Divider Order",
choices=list(zip(domdiv.main.ORDER_CHOICES,
domdiv.main.ORDER_CHOICES)),
default=domdiv.main.ORDER_CHOICES[0],
)
group_special = wtf_fields.BooleanField(
label="Group Special Cards (e.g. Prizes with Tournament)",
default=True)
group_kingdom = wtf_fields.BooleanField(
label="Group cards without randomizers separately", default=False)
# global grouping
choices = domdiv.main.GROUP_GLOBAL_CHOICES
# make pretty names for the global group choices
choiceNames = []
for choice in choices:
choiceNames.append(choice.capitalize())
group_global = wtf_fields.SelectMultipleField(
choices=list(zip(choices, choiceNames)),
label=
"Group these card types globally (Cmd/Ctrl click to select multiple)",
default="",
)
start_decks = wtf_fields.BooleanField(
label="Group four start decks with the Base cards")
curse10 = wtf_fields.BooleanField(
label="Group Curse cards into groups of ten cards")
no_trash = wtf_fields.BooleanField(label="Exclude Trash from cards")
expansion_dividers = wtf_fields.BooleanField(
label="Include Expansion Dividers", default=False)
centre_expansion_dividers = wtf_fields.BooleanField(
label="If Expansion Dividers, centre the tabs on expansion dividers",
default=False,
)
expansion_dividers_long_name = wtf_fields.BooleanField(
label=("If Expansion Dividers, use edition "
"on expansion dividers names"),
default=False,
)
set_icon = wtf_fields.SelectField(
choices=list(
zip(domdiv.main.LOCATION_CHOICES, domdiv.main.LOCATION_CHOICES)),
label="Set Icon Location",
default="tab",
)
cost = wtf_fields.SelectField(
choices=list(
zip(domdiv.main.LOCATION_CHOICES, domdiv.main.LOCATION_CHOICES)),
label="Cost Icon Location",
default="tab",
)
language = wtf_fields.SelectField(
choices=list(
zip(domdiv.main.LANGUAGE_CHOICES, domdiv.main.LANGUAGE_CHOICES)),
label="Language",
default="en_us",
)
exclude_events = wtf_fields.BooleanField(
label="Exclude Individual Events & Landmarks", default=False)
text_front = wtf_fields.SelectField(
label="Front Text",
choices=list(zip(domdiv.main.TEXT_CHOICES, domdiv.main.TEXT_CHOICES)),
default="card",
)
text_back = wtf_fields.SelectField(
label="Back Text",
choices=list(
zip(
domdiv.main.TEXT_CHOICES + ["none"],
domdiv.main.TEXT_CHOICES + ["no back page"],
)),
default="rules",
)
no_page_footer = wtf_fields.BooleanField(
label="Omit the expansion name at the bottom of the page",
default=False)
def clean_options(self):
form_options = argparse.Namespace()
self.populate_obj(form_options)
options = domdiv.main.parse_opts([])
logger.info(f"valid options: {sorted(list(vars(options).keys()))}")
is_label = False
for option, value in vars(form_options).items():
# option = option.replace('_', '-')
logger.info(f"option {option} ({type(option)}): {value}")
if option == "tab_number":
value = int(value)
if option in ["expansions", "fan"]:
value = [[v] for v in value]
if option == "cardsize":
logger.info("handling cardsize")
options.size = "unsleeved" if "Unsleeved" in value else "sleeved"
options.sleeved_thick = "Thick" in option
options.sleeved_thin = "Thin" in option
elif option == "pagesize":
logger.info("handling pagesize")
if value in PAPER_SIZES:
options.papersize = value
options.label_name = None
else:
options.label_name = value
options.papersize = "letter"
options.wrapper = False
options.notch = False
options.cropmarks = False
is_label = True
else:
assert hasattr(options,
option), f"{option} is not a script option"
if is_label and option in ["wrapper", "notch", "cropmarks"]:
logger.info(
f"skipping {option} because we're printing labels")
continue
logger.info(f"{option} --> {value}")
options.__setattr__(option, value)
if not options.group_global:
options.group_global = None
logger.info(f"options after populate: {options}")
options = domdiv.main.clean_opts(options)
logger.info(f"options after cleaning: {options}")
return options
def generate(self, num_pages=None, **kwargs):
options = self.clean_options()
if num_pages is not None:
options.num_pages = num_pages
buf = BytesIO()
options.outfile = buf
domdiv.main.generate(options)
logger.info("done generation, returning pdf")
buf.seek(0)
return buf
class LaunchProjectForm(BaseForm):
ssh_key = fields.TextAreaField('Public SSH Key', [validators.Length(max=2048)])
provider = fields.SelectField('Provider')
flavor = fields.SelectField('Flavor')
class ProductForm(form.Form):
product_name = fields.StringField(u'物品名称', [validators.Required()])
product_image = fields.StringField(u'图片', [validators.Optional()])
product_type = fields.SelectField(u'物品类型', [validators.InputRequired()], coerce=int,
choices=PRODUCT_TYPE)
recycle_gem_price = fields.IntegerField(u'回购游票价格', [validators.InputRequired()], default=0)
class GameRecommendSubscribeForm(form.Form):
game = fields.SelectField(u'游戏', [validators.InputRequired()],
coerce=ObjectId)
order = fields.IntegerField(u'显示顺序', [validators.InputRequired()],
default=0)
class TeamDetails(Form): team = fields.SelectField(u'Group', coerce=int)
class OfflineGameForm(form.Form):
status = fields.SelectField(u'状态', [validators.InputRequired()],
coerce=int,
choices=[(const.ONLINE, u'在线'),
(const.OFFLINE, u'下线'),
(const.UNDER_TEST, u'测试')])
class ExampleForm(Form):
textarea = fields.TextAreaField()
text = fields.TextField()
integer = fields.IntegerField()
datetime = fields.DateTimeField()
select = fields.SelectField(choices=[(i, i) for i in xrange(3)])
class AdminForm(flask_wtf.FlaskForm):
admin = fields.SelectField(_('Admin email'), choices=[])
submit = fields.SubmitField(_('Submit'))
class MeetingEditForm(BaseForm):
class Meta:
model = Meeting
field_args = {
'venue_address': {
'widget': widgets.TextArea()
},
'date_start': {
'format': '%d.%m.%Y',
},
'date_end': {
'format': '%d.%m.%Y',
}
}
title = ModelFormField(TranslationInputForm, label='Description')
badge_header = ModelFormField(TranslationInputForm, label='Badge header')
venue_city = ModelFormField(TranslationInputForm, label='City')
meeting_type_slug = fields.SelectField('Meeting Type')
photo_field_id = fields.SelectField('Photo Field', coerce=int)
address_field_id = fields.SelectField('Address Field', coerce=int)
telephone_field_id = fields.SelectField('Telephone Field', coerce=int)
media_photo_field_id = fields.SelectField('Media Photo Field', coerce=int)
settings = MeetingSettingsField('Settings', choices=MEETING_SETTINGS)
def __init__(self, *args, **kwargs):
super(MeetingEditForm, self).__init__(*args, **kwargs)
self.badge_header.english.validators = []
delattr(self.badge_header.english.flags, 'required')
self.meeting_type_slug.choices = [
(mt.slug, mt.label) for mt in MeetingType.query.ignore_def()]
self.photo_field_id.choices = [(0, '-----')]
self.address_field_id.choices = [(0, '-----')]
self.telephone_field_id.choices = [(0, '-----')]
self.media_photo_field_id.choices = [(0, '-----')]
if self.obj:
image_query = self.obj.custom_fields.filter_by(
field_type=CustomField.IMAGE)
participant_query = image_query.filter_by(
custom_field_type=CustomField.PARTICIPANT)
image_fields = [(x.id, x.label) for x in participant_query]
self.photo_field_id.choices += image_fields
media_query = image_query.filter_by(
custom_field_type=CustomField.MEDIA)
image_fields = [(x.id, x.label) for x in media_query]
self.media_photo_field_id.choices += image_fields
text_query = (self.obj.custom_fields
.filter_by(is_primary=False, is_protected=False)
.filter(
CustomField.field_type.in_(
[CustomField.TEXT, CustomField.TEXT_AREA])
)
)
text_fields = [(x.id, x.label) for x in text_query]
self.address_field_id.choices += text_fields
self.telephone_field_id.choices += text_fields
def validate_settings(self, field):
settings = dict(MEETING_SETTINGS)
for key in field.data:
if key not in settings:
raise ValidationError("Setting doesn't exist")
def _clean_badge_header(self, meeting):
if not self.badge_header.data['english']:
old_badge_header, meeting.badge_header = meeting.badge_header, None
if old_badge_header.id:
db.session.delete(old_badge_header)
def _save_phrases(self, meeting):
phrases_default = (
PhraseDefault.query
.filter_by(meeting_type_slug=meeting.meeting_type_slug)
)
for phrase_default in phrases_default:
phrase = copy_attributes(Phrase(), phrase_default)
phrase.description = (
copy_attributes(Translation(), phrase_default.description)
if phrase_default.description else Translation(english=''))
phrase.meeting = meeting
db.session.add(phrase)
db.session.flush()
def _save_categories(self, meeting):
for category_default in meeting.meeting_type.default_categories:
category = copy_attributes(Category(), category_default)
category.title = copy_attributes(Translation(),
category_default.title)
category.tags = category_default.tags
category.meeting = meeting
db.session.add(category)
db.session.flush()
def _save_custom_field(self, meeting):
add_custom_fields_for_meeting(meeting, form_class=ParticipantDummyForm)
query = (
CustomField.query.filter_by(meeting=meeting)
.with_entities(CustomField.sort)
.order_by(desc(CustomField.sort))
.first())
last_sort = query[0] + 1
# Copy default custom fields for meeting type
for field_default in meeting.meeting_type.default_fields:
field = copy_attributes(CustomField(), field_default)
field.label = copy_attributes(Translation(), field_default.label)
field.sort = last_sort
last_sort += 1
field.meeting = meeting
db.session.add(field)
db.session.flush()
def save(self):
meeting = self.obj or Meeting()
# Store meetings settings to prevent overwriting them
initial_settings = {k: v for k, v in (meeting.settings or {}).items()
if k not in dict(MEETING_SETTINGS)}
self.populate_obj(meeting)
meeting.settings.update(initial_settings)
meeting.photo_field_id = meeting.photo_field_id or None
meeting.address_field_id = meeting.address_field_id or None
meeting.telephone_field_id = meeting.telephone_field_id or None
meeting.media_photo_field_id = meeting.media_photo_field_id or None
self._clean_badge_header(meeting)
if meeting.id is None:
meeting.owner = current_user.staff
db.session.add(meeting)
self._save_phrases(meeting)
self._save_categories(meeting)
self._save_custom_field(meeting)
if meeting.media_participant_enabled:
add_custom_fields_for_meeting(
meeting, form_class=MediaParticipantDummyForm)
db.session.commit()
return meeting
class ManagerForm(flask_wtf.FlaskForm):
manager = fields.SelectField(_('Manager email'))
submit = fields.SubmitField(_('Submit'))
class EditProfileForm(UsernameMixin, NameMixin):
country = fields.SelectField(_('Country'), choices=[])
tz = fields.SelectField(_('Timezone'), choices=[])
pass
class AddFixedRequest(FlaskForm):
# object data
request_id = fields.HiddenField('Hidden')
object_id = fields.HiddenField('Hidden')
marshal_id = fields.HiddenField('Hidden', default=-1)
user_id = fields.HiddenField('Hidden')
allocation_id = fields.HiddenField('Hidden')
obj_name = fields.StringField('Object Name', [validators.input_required()])
status = fields.SelectField('Status',
coerce=str,
choices=[('DEFAULT', "--------"),
('EXPIRED', 'EXPIRED'),
('COMPLETED', 'COMPLETED'),
('ACTIVE', 'ACTIVE'),
('CANCELED', 'CANCELED'),
('PENDING', 'PENDING')])
obj_ra = fields.StringField('RA (HH:MM:SS or Degrees)')
obj_dec = fields.StringField('DEC (DD:MM:SS or Degrees)')
obj_epoch = fields.StringField('EPOCH', default='2000')
obj_mag = fields.FloatField('Magnitude')
allocation = fields.SelectField('allocation')
priority = fields.FloatField('priority', default=.99)
filters_op = fields.SelectField('filters',
coerce=str,
choices=[(' 1, 1, 1, 1}', 'u-g-r-i'),
(' 0, 1, 1, 1}', 'g-r-i'),
(' 0, 1, 0, 0}', 'g'),
(' 0, 0, 1, 0}', 'r'),
('0, 0, 0, 1}', 'i'),
('0, 0, 0, 0}', '-')])
do_r = fields.BooleanField('r')
do_g = fields.BooleanField('g')
do_i = fields.BooleanField('i')
do_u = fields.BooleanField('u')
r_exptime = fields.IntegerField('Exptime (seconds)', default=0)
g_exptime = fields.IntegerField('Exptime (seconds)', default=0)
i_exptime = fields.IntegerField('Exptime (seconds)', default=0)
u_exptime = fields.IntegerField('Exptime (seconds)', default=0)
r_repeats = fields.IntegerField('# Repeats', default=1)
g_repeats = fields.IntegerField('# Repeats', default=1)
i_repeats = fields.IntegerField('# Repeats', default=1)
u_repeats = fields.IntegerField('# Repeats', default=1)
rc_use_mag = fields.BooleanField(
'Use object magnitude to set exposure time')
seq_repeats = fields.IntegerField('# of Repeated Sequences', default=1)
seq_completed = fields.IntegerField('# of Sequences Already Completed',
default=0)
ifu = fields.BooleanField('Take IFU Exposure')
rc = fields.BooleanField('Take RC Exposure')
ifu_use_mag = fields.BooleanField(
'Use object magnitude to set exposure time')
ifu_exptime = fields.IntegerField(
'Enter Total IFU Exposure Time in seconds')
ab = fields.BooleanField('Select For AB pair')
cadence = fields.FloatField('cadence', default=None)
min_moon_dist = fields.FloatField(
'minimum moon distance (degrees)',
validators=(validators.Optional(), validators.number_range(0., 180.)),
default=30)
max_moon_illum = fields.FloatField(
'Maximum Moon Illumination (fractional 0 to 1)',
validators=(validators.Optional(), validators.number_range(0., 1.)),
default=1)
maxairmass = fields.FloatField('Maximum Airmass',
validators=(validators.Optional(),
validators.number_range(1, 5)),
default=2.5)
max_cloud_cover = fields.FloatField(
'Maximum Cloud Cover (fractional)',
validators=(validators.Optional(), validators.number_range(0., 1.)),
default=1)
max_fwhm = fields.FloatField('Maximum FWHM',
validators=(validators.Optional(),
validators.number_range(0., 10.)),
default=10)
phasesamples = fields.FloatField('samples per period', default=None)
sampletolerance = fields.FloatField('samples tolerance', default=None)
inidate = fields.DateField('start date (Y-m-d)',
validators=[validators.input_required()],
format='%Y-%m-%d',
default=datetime.datetime.utcnow())
enddate = fields.DateField('end date (Y-m-d)',
validators=[validators.input_required()],
format='%Y-%m-%d',
default=(datetime.datetime.utcnow() +
datetime.timedelta(days=3)))
creationdate = fields.Label('creationdate', 'Creation Date')
lastmodified = fields.Label('lastmodified', 'Last Modified')
last_obs_jd = fields.Label('last_obs_jd', 'Last observation')
submit_req = fields.SubmitField('Submit Request')
def conv_Enum(self, column, field_args, **extra):
if 'choices' not in field_args:
field_args['choices'] = [(e, e) for e in column.type.enums]
return f.SelectField(**field_args)
class ShiftForm(Form):
user = fields.SelectField('Experiment',
choices=[('error', 'FAILED TO LOAD EXPERIMENTS')
],
validators=[Required()],
default=0)
personnel = fields.TextAreaField('Shift Leader/Shift Personnel')
# USE DATETIME FORMAT OF %Y-%m-%dT%H:%M:%S FOR FILE NAME
postTime = fields.DateTimeField(
'Time to Post to E-Log',
format="%m %d %Y %H %M %S",
validators=[Required(message="Invalid date.")],
widget=SelectDateTimeWidget())
shiftStart = fields.DateTimeField(
'Shift Start Time',
format="%m %d %Y %H %M %S",
validators=[Required(message="Invalid date.")],
widget=SelectDateTimeWidget())
shiftEnd = fields.DateTimeField(
'Shift End Time',
format="%m %d %Y %H %M %S",
validators=[Required(message="Invalid date.")],
widget=SelectDateTimeWidget())
goals = fields.TextAreaField('Goals')
progress = fields.TextAreaField('Progress')
problems = fields.TextAreaField('Problems')
nextShift = fields.TextAreaField('To Do On Next Shift')
briefSummary = fields.TextAreaField('Brief Summary',
validators=[Required()])
other = fields.TextAreaField('Other Notes')
requested_time = fields.DecimalField('Beam Time Requested')
usefulBeam = fields.DecimalField('Useful Beam Time')
unschedAccDown = fields.DecimalField('Unscheduled Accelerator Downtime')
unschedUserDown = fields.DecimalField('Unscheduled User Downtime')
physAvail = fields.DecimalField(
'Accelerator Physics Group Support Available')
requested_time = fields.DecimalField('Beam Time Requested')
usesPositrons = fields.SelectField('Particle Type',
choices=[("False", 'Electrons'),
("True", 'Positrons')],
default="False")
numParticles = fields.DecimalField('Bunch Charge')
x_rms_li20 = fields.DecimalField('X RMS Wire Size (μm)')
y_rms_li20 = fields.DecimalField('Y RMS Wire Size (μm)')
bunch_length = fields.DecimalField('Bunch Length (μm)')
# This is like a weird __init__ since I couldn't get __init__ to work properly
def setForm(self):
self.setUserChoices()
def setUserChoices(self):
choices = [
('', 'Please Select')
] # Empty string means that required validator returns false
users = models.User.query.order_by('name asc').all()
for u in users:
choices.append(
(str(u.id),
u)) # Two parenthesis since the choice pairs are tuples
self.user.choices = choices
def read_report(self, report):
self.user.data = str(report.user) # Must use string for form.
self.personnel.data = report.personnel
self.postTime.data = report.postTime
self.shiftStart.data = report.shiftStart
self.shiftEnd.data = report.shiftEnd
self.goals.data = report.goals
self.progress.data = report.progress
self.problems.data = report.problems
self.nextShift.data = report.nextShift
self.briefSummary.data = report.briefSummary
self.other.data = report.other
self.usefulBeam.data = report.usefulBeam
self.unschedAccDown.data = report.unschedAccDown
self.unschedUserDown.data = report.unschedUserDown
self.physAvail.data = report.physAvail
self.requested_time.data = report.requested_time
self.usesPositrons.data = "True" if report.usesPositrons else "False"
self.numParticles.data = report.numParticles
self.x_rms_li20.data = report.x_rms_li20
self.y_rms_li20.data = report.y_rms_li20
self.bunch_length.data = report.bunch_length
