class TrackUpdateForm(wtf.Form):
album = wtforms.StringField('Album', filters=[util.strip_filter])
title = wtforms.StringField('Title', filters=[util.strip_filter])
artist = wtforms.StringField('Artist', filters=[util.strip_filter])
albumartist = wtforms.StringField('Album Artist',
filters=[util.strip_filter])
originaldate = wtforms.StringField('Original Date',
filters=[util.strip_filter])
composer = wtforms.StringField('Composer', filters=[util.strip_filter])
lyricist = wtforms.StringField('Lyricist', filters=[util.strip_filter])
writer = wtforms.StringField('Writer', filters=[util.strip_filter])
totaltracks = wtforms.IntegerField('Total Tracks')
discnumber = wtforms.IntegerField('Disc Number')
genre = wtforms.SelectMultipleField(
'Genre',
choices=[(t, t.title()) for t in model.Track.genre_list().keys()],
default="unknown")
mood = wtforms.SelectMultipleField(
'Mood',
choices=[(t, t.title()) for t in model.Track.genre_list().keys()],
default="Okay")
rating = wtforms.IntegerField('Rating')
musicbrainz_recordingid = wtforms.StringField('musicbrainz_recordingid',
filters=[util.strip_filter])
musicbrainz_trackid = wtforms.StringField('musicbrainz_trackid',
filters=[util.strip_filter])
musicbrainz_albumid = wtforms.StringField('musicbrainz_albumid',
filters=[util.strip_filter])
musicbrainz_artistid = wtforms.StringField('musicbrainz_artistid',
filters=[util.strip_filter])
musicbrainz_albumartistid = wtforms.StringField(
'musicbrainz_albumartistid', filters=[util.strip_filter])
language = wtforms.StringField('language', filters=[util.strip_filter])
website = wtforms.StringField('website', filters=[util.strip_filter])
stream_url = wtforms.StringField('stream_url', filters=[util.strip_filter])
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 ScalingGroupsFiltersForm(BaseSecureForm):
"""Form class for filters on landing page"""
launch_config_name = wtforms.SelectMultipleField(label=_(u'Launch configuration'))
availability_zones = wtforms.SelectMultipleField(label=_(u'Availability zone'))
vpc_zone_identifier = wtforms.SelectMultipleField(label=_(u'VPC subnet'))
tags = TextEscapedField(label=_(u'Tags'))
def __init__(self, request,
ec2_conn=None, autoscale_conn=None, vpc_conn=None, **kwargs):
super(ScalingGroupsFiltersForm, self).__init__(request, **kwargs)
self.request = request
self.ec2_conn = ec2_conn
self.autoscale_conn = autoscale_conn
self.vpc_conn = vpc_conn
self.ec2_choices_manager = ChoicesManager(conn=ec2_conn)
self.autoscale_choices_manager = ChoicesManager(conn=autoscale_conn)
self.vpc_choices_manager = ChoicesManager(conn=vpc_conn)
self.launch_config_name.choices = self.autoscale_choices_manager.launch_configs(add_blank=False)
self.availability_zones.choices = self.ec2_choices_manager.availability_zones(self.region, add_blank=False)
self.vpc_zone_identifier.choices = self.vpc_choices_manager.vpc_subnets(add_blank=False)
self.cloud_type = request.session.get('cloud_type', 'euca')
if self.cloud_type == 'aws':
self.vpc_zone_identifier.choices.append(('None', _(u'No subnets')))
self.vpc_zone_identifier.choices = sorted(self.vpc_zone_identifier.choices)
self.facets = [
{'name': 'launch_config_name', 'label': self.launch_config_name.label.text,
'options': self.get_options_from_choices(self.launch_config_name.choices)},
{'name': 'availability_zones', 'label': self.availability_zones.label.text,
'options': self.get_options_from_choices(self.availability_zones.choices)},
]
if BaseView.is_vpc_supported(request):
self.facets.append(
{'name': 'vpc_zone', 'label': self.vpc_zone_identifier.label.text,
'options': self.get_options_from_choices(self.vpc_zone_identifier.choices)}
)
class RequestAclPackageForm(wtf.Form):
""" Form to request ACLs on a package. """
branches = wtforms.SelectMultipleField(
'Branch',
[wtforms.validators.Required()],
choices=[('', '')])
acl = wtforms.SelectMultipleField(
'ACL',
[wtforms.validators.Required()],
choices=[('', '')]
)
def __init__(self, *args, **kwargs):
""" Calls the default constructor with the normal argument but
uses the list of collection provided to fill the choices of the
drop-down list.
"""
super(RequestAclPackageForm, self).__init__(*args, **kwargs)
if 'collections' in kwargs:
self.branches.choices = [
(collec.branchname, collec.branchname)
for collec in kwargs['collections']
]
if 'pkg_acl_list' in kwargs:
self.acl.choices = [
(status, status)
for status in kwargs['pkg_acl_list']
]
class UpdateAclPackageForm(wtf.Form):
pkg_branch = wtforms.SelectMultipleField('Branch',
[wtforms.validators.Required()],
choices=[('', '')])
pkg_acl = wtforms.SelectMultipleField('ACL',
[wtforms.validators.Required()],
choices=[(item, item)
for item in []])
acl_status = wtforms.SelectField('Status', [wtforms.validators.Required()],
choices=[(item, item) for item in []])
def __init__(self, *args, **kwargs):
""" Calls the default constructor with the normal arguments.
Fill the SelectField using the additionnal arguments provided.
"""
super(UpdateAclPackageForm, self).__init__(*args, **kwargs)
if 'collections' in kwargs:
self.pkg_branch.choices = [(collec, collec)
for collec in kwargs['collections']]
if 'pkg_status' in kwargs:
self.acl_status.choices = [(status, status)
for status in kwargs['pkg_status']]
if 'pkg_acl_list' in kwargs:
self.pkg_acl.choices = [(status, status)
for status in kwargs['pkg_acl_list']]
class SetAclPackageForm(wtf.Form):
""" Form to set ACLs to someone on a package. """
pkgname = wtforms.TextField('Package name',
[wtforms.validators.Required()])
branches = wtforms.SelectMultipleField('Branch',
[wtforms.validators.Required()],
choices=[('', '')])
acl = wtforms.SelectMultipleField('ACL', [wtforms.validators.Required()],
choices=[(item, item) for item in []])
user = wtforms.TextField('Packager name', [wtforms.validators.Required()])
acl_status = wtforms.SelectField('Status', [wtforms.validators.Required()],
choices=[(item, item) for item in []])
def __init__(self, *args, **kwargs):
""" Calls the default constructor with the normal argument but
uses the list of collection provided to fill the choices of the
drop-down list.
"""
super(SetAclPackageForm, self).__init__(*args, **kwargs)
if 'collections' in kwargs:
self.branches.choices = [(collec, collec)
for collec in kwargs['collections']]
if 'collections_obj' in kwargs:
self.branches.choices = [(collec.branchname, collec.branchname)
for collec in kwargs['collections_obj']]
if 'acl_status' in kwargs:
self.acl_status.choices = [(status, status)
for status in kwargs['acl_status']]
if 'pkg_acl' in kwargs:
self.acl.choices = [(acl, acl) for acl in kwargs['pkg_acl']]
class RestaurantForm(FlaskForm):
name = f.StringField("name", validators=[DataRequired()])
## FIXME(vincenzopalazzo) modify the phone length
phone = f.StringField("phone",
validators=[DataRequired(),
Length(min=8, max=15)])
lat = f.StringField("latitude", validators=[DataRequired()])
lon = f.StringField("longitude", validators=[DataRequired()])
n_tables = f.StringField("Number of tables for 6 People",
validators=[DataRequired()])
covid_measures = f.StringField("Anti-Covid measures",
validators=[DataRequired()])
# photo = f.FileField("Photo of restaurant")
cuisine = f.SelectMultipleField(
"Cuisine Type",
choices=[
("Italian food", "Italian food"),
("Chinese food", "Chinese food"),
("Indian Food", "Indian Food"),
("Japanese Food", "Japanese Food"),
("Other", "Other"),
],
validators=[DataRequired()],
)
open_days = f.SelectMultipleField(
"Opening days",
choices=[
("0", "Monday"),
("1", "Tuesday"),
("2", "Wednesday"),
("3", "Thursday"),
("4", "Friday"),
("5", "Saturday"),
("6", "Sunday"),
],
validators=[DataRequired()],
)
open_lunch = f.TimeField("open time for lunch",
validators=[DataRequired()])
close_lunch = f.TimeField("close time for lunch",
validators=[DataRequired()])
open_dinner = f.TimeField("open time for dinner",
validators=[DataRequired()])
close_dinner = f.TimeField("close time for dinner",
validators=[DataRequired()])
display = [
"name",
"phone",
"lat",
"lon",
"n_tables",
"cuisine",
"open_days",
"open_lunch",
"close_lunch",
"open_dinner",
"close_dinner",
"covid_measures",
]
class ConfigForm(wtf.Form):
office_ip = wtf.TextField(_(u"Office IP prefixes"),
validators=[validators.Required()])
google_user_email = wtf.TextField(_(u'Google User Email'),
validators=[
validators.Email(),
validators.Required(),
validators.Length(min=6, max=64)
])
google_user_password = StarredPasswordField(
_(u'Google User Password'),
validators=[validators.Required(),
validators.Length(min=6, max=64)])
holidays_spreadsheet = wtf.TextField(_(u"Holidays Spreadsheet"),
validators=[validators.Required()])
hours_employee_project = wtf.TextField(
_(u"Hours employee - project Spreadsheet"),
validators=[validators.Required()])
cleaning_time_presence = wtf.IntegerField(_(u'Cleaning time presence'),
validators=[
validators.Required(),
])
absence_project_id = wtf.SelectField(_(u'Absence project'),
validators=[],
choices=ProjectChoices(
skip_inactive=True, empty=True))
reports_project_ids = wtf.SelectMultipleField(
_(u'Daily report - include projects'),
validators=[],
choices=ProjectChoices())
reports_omit_user_ids = wtf.SelectMultipleField(
_(u'Daily report - omit user'), validators=[], choices=UserChoices())
reports_without_ticket_project_ids = wtf.SelectMultipleField(
_(u'Daily report without ticket - include projects'),
validators=[],
choices=ProjectChoices())
reports_without_ticket_omit_user_ids = wtf.SelectMultipleField(
_(u'Daily report without ticket - omit user'),
validators=[],
choices=UserChoices())
freelancers = wtf.TextAreaField(
_(u"Freelancers"),
validators=[ListValidator(validators=[validators.Email()])])
hours_ticket_user_id = wtf.SelectField(
_(u'Hours per ticket synchronization user credentials'),
validators=[],
choices=UserChoices(empty=False))
monthly_late_limit = wtf.IntegerField(_(u'Monthly late limit'),
validators=[
validators.Required(),
])
monthly_incorrect_time_record_limit = wtf.IntegerField(
_(u'Monthly incorrect time record limit'),
validators=[
validators.Required(),
])
class RecipeForm(flask_wtf.FlaskForm):
name = wtforms.StringField(
"Recipe name", validators=[wtforms.validators.DataRequired()]
)
products = wtforms.SelectMultipleField(
"Products", validators=[wtforms.validators.DataRequired()],
)
instruction = wtforms.StringField("Instruction")
categories = wtforms.SelectMultipleField(
"Categories", choices=[(c, c) for c in CATEGORIES_LIST]
)
submit = wtforms.SubmitField("Create")
class UserEditForm(wtf.Form):
""" Admin edits freelancer's profile """
def process(self, formdata=None, obj=None, **kwargs):
if isinstance(obj, User):
kwargs['level'] = obj.levels_list
super(UserEditForm, self).process(formdata, obj, **kwargs)
is_active = wtf.BooleanField(_(u"Is active"), validators=[])
is_programmer = wtf.BooleanField(_(u"Is programmer"), validators=[])
is_frontend_developer = wtf.BooleanField(_(u"Is frontend developer"),
validators=[])
is_graphic_designer = wtf.BooleanField(_(u"Is graphic designer"),
validators=[])
avatar = wtf.HiddenField()
level = wtf.SelectMultipleField(_(u'Role'), validators=[], choices=levels)
start_work = wtf.DateField(_(u"Start work"),
format='%d/%m/%Y',
validators=[])
start_full_time_work = wtf.DateField(_(u"Start full time work"),
format='%d/%m/%Y',
validators=[validators.Optional()])
description = wtf.TextField(_(u"Description"),
validators=[validators.Optional()])
location = wtf.SelectField(_(u"Office location"),
choices=[('', u'--None--')] +
[(k, v[0]) for k, v in User.LOCATIONS.items()])
availability_link = wtf.TextField(
_(u"Availability calendar link"),
validators=[validators.Optional(),
validators.URL()])
tasks_link = wtf.TextField(
_(u"Tasks calendar link"),
validators=[validators.Optional(),
validators.URL()])
skype = wtf.TextField(_(u"Skype"), validators=[validators.Optional()])
phone = wtf.TextField(_(u"Phone"), validators=[validators.Optional()])
phone_on_desk = wtf.TextField(_(u"Deskphone"),
validators=[validators.Optional()])
irc = wtf.TextField(_(u"IRC"), validators=[validators.Optional()])
groups = wtf.SelectMultipleField(_(u'Groups'),
validators=[],
choices=(
('freelancer', 'freelancer'),
('user', 'user'),
('admin', 'admin'),
))
class UserEditForm(wtf.Form):
""" Admin edits freelancer's profile """
employment_contract = wtf.BooleanField(_(u"Employment contract"),
validators=[])
is_active = wtf.BooleanField(_(u"Is active"), validators=[])
avatar = wtf.HiddenField()
roles = wtf.SelectMultipleField(_(u'Role'),
validators=[],
choices=User.ROLES)
start_work = wtf.DateField(_(u"Start work"),
format='%d/%m/%Y',
validators=[])
start_full_time_work = wtf.DateField(_(u"Start full time work"),
format='%d/%m/%Y',
validators=[validators.Optional()])
stop_work = wtf.DateField(_(u"Stop work"),
format='%d/%m/%Y',
validators=[validators.Optional()])
description = wtf.TextField(_(u"Description"),
validators=[validators.Optional()])
date_of_birth = wtf.DateField(_(u"Date of birth"),
format='%d/%m/%Y',
validators=[validators.Optional()])
location = wtf.SelectField(_(u"Office location"),
choices=[('', u'--None--')] +
[(k, v[0]) for k, v in User.LOCATIONS.items()])
availability_link = wtf.TextField(
_(u"Availability calendar link"),
validators=[validators.Optional(),
validators.URL()])
tasks_link = wtf.TextField(
_(u"Tasks calendar link"),
validators=[validators.Optional(),
validators.URL()])
skype = wtf.TextField(_(u"Skype"), validators=[validators.Optional()])
phone = wtf.TextField(_(u"Phone"), validators=[validators.Optional()])
phone_on_desk = wtf.TextField(_(u"Deskphone"),
validators=[validators.Optional()])
irc = wtf.TextField(_(u"IRC"), validators=[validators.Optional()])
groups = wtf.SelectMultipleField(_(u'Groups'),
validators=[],
choices=(('freelancer',
'freelancer'), ('user', 'user'),
('admin', 'admin'), ('scrum',
'scrum')))
class ReportsForm(wtf.Form):
reports_project_ids = wtf.SelectMultipleField(
_(u'Daily report - include projects'),
validators=[],
choices=ProjectChoices())
reports_omit_user_ids = wtf.SelectMultipleField(
_(u'Daily report - omit user'), validators=[], choices=UserChoices())
reports_without_ticket_project_ids = wtf.SelectMultipleField(
_(u'Daily report without ticket - include projects'),
validators=[],
choices=ProjectChoices())
reports_without_ticket_omit_user_ids = wtf.SelectMultipleField(
_(u'Daily report without ticket - omit user'),
validators=[],
choices=UserChoices())
class F(ReactorForm):
es_index = wtforms.SelectMultipleField('Elasticsearch',
choices=[(ix, '')
for ix in es_indices])
pg_index = wtforms.SelectMultipleField('pg',
choices=[(ix, '')
for ix in pg_indices])
confirm = wtforms.TextField('Confirm',
filters=[uppercase_filter, strip_filter],
validators=[
wtforms.validators.AnyOf(['CONFIRM']),
wtforms.validators.DataRequired()
])
ignore_labels = ['submit']
css_classes = {'submit': 'btn btn-danger'}
class VolumesFiltersForm(BaseSecureForm):
"""Form class for filters on landing page"""
zone = wtforms.SelectMultipleField(label=_(u'Availability zones'))
status = wtforms.SelectMultipleField(label=_(u'Status'))
tags = TextEscapedField(label=_(u'Tags'))
def __init__(self, request, conn=None, **kwargs):
super(VolumesFiltersForm, self).__init__(request, **kwargs)
self.request = request
self.choices_manager = ChoicesManager(conn=conn)
self.zone.choices = self.get_availability_zone_choices()
self.status.choices = self.get_status_choices()
self.facets = [
{
'name': 'zone',
'label': self.zone.label.text,
'options': self.get_availability_zone_choices()
},
{
'name': 'status',
'label': self.status.label.text,
'options': self.get_status_choices()
},
]
def get_availability_zone_choices(self):
return self.get_options_from_choices(
self.choices_manager.availability_zones(self.region,
add_blank=False))
@staticmethod
def get_status_choices():
return [{
'key': 'creating',
'label': _(u'Creating')
}, {
'key': 'available',
'label': _(u'Available')
}, {
'key': 'attached',
'label': _(u'Attached')
}, {
'key': 'attaching',
'label': _(u'Attaching')
}, {
'key': 'detaching',
'label': _(u'Detaching')
}]
class RequestPackageForm(wtf.Form):
""" Form to request a new package. """
pkgname = wtforms.TextField('Package name', [
wtforms.validators.Required(),
wtforms.validators.Regexp(PKG_NAME_RE, flags=re.IGNORECASE),
])
summary = wtforms.TextField('Summary', [wtforms.validators.Required()])
description = wtforms.TextAreaField('Description', )
review_url = wtforms.TextField('Ticket number or URL',
[wtforms.validators.Required()])
branches = wtforms.SelectMultipleField('Collection',
[wtforms.validators.Required()],
choices=[(item, item)
for item in []])
upstream_url = wtforms.TextField('Upstream URL',
[wtforms.validators.optional()])
namespace = wtforms.SelectField('Namespace',
[wtforms.validators.Required()],
choices=[(item, item) for item in []])
def __init__(self, *args, **kwargs):
""" Calls the default constructor with the normal argument but
uses the list of collection provided to fill the choices of the
drop-down list.
"""
super(RequestPackageForm, self).__init__(*args, **kwargs)
if 'collections' in kwargs:
self.branches.choices = [(collec.branchname, collec.branchname)
for collec in kwargs['collections']]
if 'namespaces' in kwargs:
self.namespace.choices = [(ns, ns) for ns in kwargs['namespaces']]
class SnapshotsFiltersForm(BaseSecureForm):
"""Form class for filters on landing page"""
status = wtforms.SelectMultipleField(label=_(u'Status'))
tags = TextEscapedField(label=_(u'Tags'))
def __init__(self, request, **kwargs):
super(SnapshotsFiltersForm, self).__init__(request, **kwargs)
self.request = request
self.status.choices = self.get_status_choices()
self.facets = [
{
'name': 'status',
'label': self.status.label.text,
'options': self.get_status_choices()
},
]
@staticmethod
def get_status_choices():
return [
{
'key': 'pending',
'label': _(u'In progress')
},
{
'key': 'completed',
'label': _(u'Completed')
},
]
class EventForm(FlaskForm):
try:
user_list = [(u.id, u.username) for u in models.Users.query.all()]
except Exception:
user_list = []
try:
dog_list = [(d.id, d.name) for d in models.Dog.query.all()]
except Exception:
dog_list = []
try:
event_type_list = [(i.id, i.name.capitalize()) for i in models.EventType.query.all()]
except Exception:
event_type_list = []
# TODO: Default get current user
user = wtforms.SelectField('User', choices=user_list, coerce=int, validators=[validators.data_required()])
dog = wtforms.SelectMultipleField('Dog', choices=dog_list, coerce=int, validators=[validators.data_required()])
event = wtforms.SelectField('Event', choices=event_type_list, coerce=int)
date = html5.DateField('Date', validators=[validators.Optional()], default=datetime.date.today)
start_time = html5.TimeField('Start Time', validators=[validators.Optional()], default=datetime.datetime.now())
end_time = html5.TimeField('End Time', validators=[validators.Optional()], default=None)
note = wtforms.StringField('Note', default=None)
accident = wtforms.BooleanField('Accident?')
submit = wtforms.SubmitField('Submit')
class RestaurantForm(FlaskForm):
name = f.StringField('Name', validators=[DataRequired()])
lat = f.FloatField('Latitude', validators=[DataRequired()])
lon = f.FloatField('Longitude', validators=[DataRequired()])
phone = f.StringField('Phone', validators=[DataRequired()])
# Note: the capacity is automatically derived from tables settings
cuisine_type = f.SelectMultipleField(
'Cuisine types',
choices = Restaurant.CUISINE_TYPES.choices(),
coerce = Restaurant.CUISINE_TYPES.coerce,
validators=[DataRequired()]
)
prec_measures = f.TextAreaField('Precautionary measures',validators=[DataRequired()])
avg_time_of_stay = f.IntegerField('Average time of stay (in minutes)', validators=[DataRequired(), NumberRange(min=15)])
workingdays = f.FieldList(f.FormField(WorkingDayForm), min_entries=1, max_entries=7)
tables = f.FieldList(f.FormField(TableForm), min_entries=1, max_entries=100)
dishes = f.FieldList(f.FormField(DishForm), min_entries=1, max_entries=100)
display = ['name', 'lat', 'lon', 'phone', 'cuisine_type', 'prec_measures', 'avg_time_of_stay']
def validate_workingdays(form, field):
days_already_added = []
for wd in field.data:
if wd['day'] in days_already_added:
raise ValidationError("There cannot be two working days with the same day")
else:
days_already_added.append(wd['day'])
class AdminUserAccountForm(BaseUserAccountForm):
"""
Class representing base user account form for admins.
"""
enabled = wtforms.RadioField(lazy_gettext('State:'),
validators=[
wtforms.validators.InputRequired(),
],
choices=[(True, lazy_gettext('Enabled')),
(False, lazy_gettext('Disabled'))],
filters=[mydojo.forms.str_to_bool],
coerce=mydojo.forms.str_to_bool)
roles = wtforms.SelectMultipleField(
lazy_gettext('Roles:'), validators=[wtforms.validators.Optional()])
memberships = QuerySelectMultipleField(lazy_gettext('Group memberships:'),
query_factory=get_available_groups)
managements = QuerySelectMultipleField(lazy_gettext('Group managements:'),
query_factory=get_available_groups)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
#
# Handle additional custom keywords.
#
# The list of choices for 'roles' attribute comes from outside of the
# form to provide as loose tie as possible to the outer application.
# Another approach would be to load available choices here with:
#
# roles = flask.current_app.config['ROLES']
#
# That would mean direct dependency on flask.Flask application.
self.roles.choices = kwargs['choices_roles']
class SecurityGroupsFiltersForm(BaseSecureForm):
"""Form class for filters on landing page"""
vpc_id = wtforms.SelectMultipleField(label=_(u'VPC network'))
tags = TextEscapedField(label=_(u'Tags'))
def __init__(self, request, vpc_conn=None, cloud_type='euca', **kwargs):
super(SecurityGroupsFiltersForm, self).__init__(request, **kwargs)
self.request = request
self.cloud_type = cloud_type
self.vpc_choices_manager = ChoicesManager(conn=vpc_conn)
self.vpc_id.choices = self.vpc_choices_manager.vpc_networks(
add_blank=False)
if self.cloud_type == 'aws':
self.vpc_id.choices.append(('None', _(u'No VPC')))
self.vpc_id.choices = sorted(self.vpc_id.choices)
self.facets = []
if BaseView.is_vpc_supported(request):
self.facets.append({
'name':
'vpc_id',
'label':
self.vpc_id.label.text,
'options':
self.get_options_from_choices(self.vpc_id.choices)
})
class AddPackageForm(wtf.Form):
""" Form to add or edit packages. """
pkgname = wtforms.TextField('Package name <span class="error">*</span>',
[wtforms.validators.Required()])
summary = wtforms.TextField('Summary <span class="error">*</span>',
[wtforms.validators.Required()])
description = wtforms.TextField('Description', )
review_url = wtforms.TextField('Review URL',
[wtforms.validators.Required()])
status = wtforms.SelectField('Status', [wtforms.validators.Required()],
choices=[(item, item) for item in []])
critpath = wtforms.BooleanField('Package in critpath', default=False)
branches = wtforms.SelectMultipleField('Collection',
[wtforms.validators.Required()],
choices=[(item, item)
for item in []])
poc = wtforms.TextField('Point of contact <span class="error">*</span>',
[wtforms.validators.Required()])
upstream_url = wtforms.TextField('Upstream URL',
[wtforms.validators.optional()])
def __init__(self, *args, **kwargs):
""" Calls the default constructor with the normal argument but
uses the list of collection provided to fill the choices of the
drop-down list.
"""
super(AddPackageForm, self).__init__(*args, **kwargs)
if 'collections' in kwargs:
self.branches.choices = [(collec.branchname, collec.branchname)
for collec in kwargs['collections']]
if 'pkg_status_list' in kwargs:
self.status.choices = [(status, status)
for status in kwargs['pkg_status_list']]
class CheckoutForm(Form):
contents = wtforms.SelectMultipleField(
choices=[(k, v.title) for k, v in six.iteritems(exportables)],
validators=[
wtforms.validators.InputRequired()])
expand_collections = wtforms.BooleanField(default=False)
use_choice_labels = wtforms.BooleanField(default=False)
class NewTokenForm(PagureForm):
""" Form to add a new token. """
description = wtforms.StringField("description",
[wtforms.validators.Optional()])
expiration_date = wtforms.DateField(
"expiration date",
[wtforms.validators.DataRequired()],
default=datetime.date.today() + datetime.timedelta(days=(30 * 6)),
)
acls = wtforms.SelectMultipleField("ACLs",
[wtforms.validators.DataRequired()],
choices=[])
def __init__(self, *args, **kwargs):
""" Calls the default constructor with the normal argument but
uses the list of collection provided to fill the choices of the
drop-down list.
"""
super(NewTokenForm, self).__init__(*args, **kwargs)
if "acls" in kwargs:
self.acls.choices = [(acl.name, acl.name)
for acl in kwargs["acls"]]
if "sacls" in kwargs:
self.acls.choices = [(acl, acl) for acl in kwargs["sacls"]]
class ProjectTimeForm(wtf.Form):
date_range = utils.DateRangeField(
u'Date range',
validators=[validators.Required()],
format='%d-%m-%Y',
default=lambda: h.start_end_month(datetime.date.today()),
)
projects = wtf.SelectMultipleField(
_(u'Projects'),
choices=ProjectChoices(skip_inactive=True),
validators=[])
group_by_client = wtf.BooleanField(_(u'Group by client'), default=True)
group_by_project = wtf.BooleanField(_(u'Group by project'), default=True)
group_by_bugs = wtf.BooleanField(_(u'Group by bugs'), default=True)
group_by_user = wtf.BooleanField(_(u'Group by employee'), default=True)
ticket_choice = wtf.RadioField(_('Tickets'),
choices=[
('all', 'All'),
('without_bug_only',
'Without bugs only'),
('meetings_only', 'Meetings only'),
],
default='all')
bigger_than = wtf.IntegerField(_('Bigger than'), default=0)
def __init__(self, *args, **kwargs):
super(ProjectTimeForm, self).__init__(*args, **kwargs)
client = kwargs.pop('client', None)
self.projects.choices = ProjectChoices(client=client,
skip_inactive=True)
class HoursWorkedReportFormBase(wtf.Form):
date_range = wtf.SelectField(_(u'Report for'),
validators=[],
choices=[('0', u'date range'),
('1', u'current quarter'),
('2', u'previous quarter'),
('3', u'current year'),
('4', u'previous year')],
default='0')
start_date = wtf.DateField(_(u'Start'),
validators=[DataValidator(format='%d/%m/%Y')],
format='%d/%m/%Y',
default=datetime.date(today().year,
today().month, 1))
end_date = wtf.DateField(_(u'End'),
validators=[DataValidator(format='%d/%m/%Y')],
format='%d/%m/%Y',
default=end_month)
user_id = wtf.SelectMultipleField(_(u'Employees'),
validators=[],
choices=EmployeeChoices(inactive=True))
only_fully_employed = wtf.BooleanField(_(u'Full time employees only'),
default=True)
only_red = wtf.BooleanField(_(u'Red only'), default=True)
group_by_month = wtf.BooleanField(_(u'Group by month'), default=True)
class UserUpdateForm(flask_wtf.FlaskForm):
username = wtforms.StringField(
model.User.username._verbose_name,
[wtforms.validators.required(), wtforms.validators.length(min=2)],
filters=[util.email_filter],
)
name = wtforms.StringField(
model.User.name._verbose_name,
[wtforms.validators.required()], filters=[util.strip_filter],
)
email = wtforms.StringField(
model.User.email._verbose_name,
[wtforms.validators.optional(), wtforms.validators.email()],
filters=[util.email_filter],
)
admin = wtforms.BooleanField(model.User.admin._verbose_name)
active = wtforms.BooleanField(model.User.active._verbose_name)
verified = wtforms.BooleanField(model.User.verified._verbose_name)
permissions = wtforms.SelectMultipleField(
model.User.permissions._verbose_name,
filters=[util.sort_filter],
)
_permission_choices = set()
def __init__(self, *args, **kwds):
super(UserUpdateForm, self).__init__(*args, **kwds)
self.permissions.choices = [
(p, p) for p in sorted(UserUpdateForm._permission_choices)
]
@auth.permission_registered.connect
def _permission_registered_callback(sender, permission):
UserUpdateForm._permission_choices.add(permission)
class AddPackageForm(wtf.Form):
pkg_name = wtforms.TextField('Package name',
[wtforms.validators.Required()])
pkg_summary = wtforms.TextField('Summary', [wtforms.validators.Required()])
pkg_reviewURL = wtforms.TextField('Review URL',
[wtforms.validators.Required()])
pkg_status = wtforms.SelectField('Status', [wtforms.validators.Required()],
choices=[(item, item) for item in []])
pkg_shouldopen = wtforms.BooleanField('Should open',
[wtforms.validators.Required()],
default=True)
pkg_collection = wtforms.SelectMultipleField(
'Collection', [wtforms.validators.Required()],
choices=[(item, item) for item in []])
pkg_poc = wtforms.TextField('Point of contact',
[wtforms.validators.Required()])
pkg_upstreamURL = wtforms.TextField('Upstream URL',
[wtforms.validators.optional()])
def __init__(self, *args, **kwargs):
""" Calls the default constructor with the normal argument but
uses the list of collection provided to fill the choices of the
drop-down list.
"""
super(AddPackageForm, self).__init__(*args, **kwargs)
if 'collections' in kwargs:
self.pkg_collection.choices = [(collec.branchname,
collec.branchname)
for collec in kwargs['collections']]
if 'pkg_status_list' in kwargs:
self.pkg_status.choices = [(status, status)
for status in kwargs['pkg_status_list']]
class ImagesFiltersForm(BaseSecureForm):
"""Form class for filters on landing page"""
owner_alias = wtforms.SelectField(label=_(u'Images owned by'))
platform = wtforms.SelectMultipleField(label=_(u'Platform'))
root_device_type = wtforms.SelectMultipleField(label=_(u'Root device type'))
architecture = wtforms.SelectMultipleField(label=_(u'Architecture'))
tags = wtforms.TextField(label=_(u'Tags'))
def __init__(self, request, cloud_type='euca', **kwargs):
super(ImagesFiltersForm, self).__init__(request, **kwargs)
self.request = request
self.cloud_type = cloud_type
self.owner_alias.choices = self.get_owner_choices()
self.platform.choices = self.get_platform_choices()
self.root_device_type.choices = self.get_root_device_type_choices()
self.architecture.choices = self.get_architecture_choices()
if cloud_type == 'aws' and not self.request.params.get('owner_alias'):
self.owner_alias.data = 'amazon' # Default to Amazon AMIs on AWS
def get_owner_choices(self):
owner_choices = EUCA_IMAGE_OWNER_ALIAS_CHOICES
if self.cloud_type == 'aws':
owner_choices = AWS_IMAGE_OWNER_ALIAS_CHOICES
return owner_choices
def get_platform_choices(self):
if self.cloud_type == 'euca':
return (
('linux', 'Linux'),
('windows', 'Windows'),
)
else:
return ('windows', 'Windows'),
@staticmethod
def get_root_device_type_choices():
return (
('ebs', 'EBS'),
('instance-store', 'Instance-store'),
)
@staticmethod
def get_architecture_choices():
return (
('x86_64', '64-bit'),
('i386', '32-bit'),
)
class MovieSearchForm(wtforms.Form):
title = wtforms.TextField(u'Title', [wtforms.validators.length(max=50)])
adname = wtforms.TextField(u'Actor or Director Name',
[wtforms.validators.length(max=50)])
genres = wtforms.SelectMultipleField(
u'Genre',
choices=MOVIE_GENRES,
)
rating = wtforms.SelectMultipleField(
u'Ratings',
choices=MOVIE_RATINGS[1:],
)
search = wtforms.HiddenField(u'search', )
class DeleteTagForm(flask_wtf.FlaskForm):
del_name = wtforms.SelectMultipleField('', coerce=int, validators=[wtforms.validators.DataRequired()])
submit = wtforms.SubmitField('删除标签')
def __init__(self, *args, **kwargs):
super(DeleteTagForm, self).__init__(*args, **kwargs)
self.del_name.choices = [(tag.id, tag.name)
for tag in Tag.query.order_by(Tag.id).all()]
