def show_reports():
form = FlaskForm()
if form.validate_on_submit():
vcf_id = request.form['vcfs'].split(',')[0]
url = urlparse.urlparse(request.form['url'])
args = MultiDict(urlparse.parse_qsl(url.query))
response = jsonapi.get_related(db, args, 'vcfs', vcf_id, 'calls')
title = request.form.get('title')
if response.status == requests.codes.ok:
report = Report(title)
report.vcfs = [VCF.query.get(vcf_id)]
report.creator = current_user
report.project = Project.query.get(request.form.get('project'))
report.panels = Panel.query.filter(Panel.id.in_(request.form.get('panels').split(','))).all()
report.fisher = request.form.get('fisher')
report.artifact = request.form.get('artifact')
report.frequency = request.form.get('frequency')
report.depth = request.form.get('depth')
report.content = cPickle.dumps(response.document)
db.add(report)
try:
db.commit()
except SQLAlchemyError:
flash("Error saving report: '{0}'. Please try again later.".format(title), category='danger')
else:
flash("Report: '{0}' saved successfully.".format(title), category='success')
admin = current_user.is_authenticated and PERMISSION.MANAGE_REPORT_REQUEST in current_user.permissions
return render_template('reports/index.html', admin=admin)
def update_datacite(self):
"""."""
form = UpdateDataciteForm()
cancel_or_new_task_form = FlaskForm()
is_task_running = False
time = 0
task_details = current_cache.get('update_datacite:task_details')
if task_details:
is_task_running = True
if cancel_or_new_task_form.validate_on_submit():
current_cache.set('update_datacite:task_details', None)
return redirect(url_for('updatedataciteview.update_datacite'))
else:
if form.validate_on_submit():
from_date = request.form['from_date']
until_date = request.form['until_date']
action = request.form['action']
if action == 'SubmitDates':
if from_date > until_date:
flash("Error: the 'From' date should precede the 'Until' date.")
else:
pids_count = find_registered_doi_pids(from_date,
until_date,
current_app.config['ZENODO_LOCAL_DOI_PREFIXES']).count()
task_details = dict(
total_pids=pids_count
)
time = pids_count/current_app.config['DATACITE_UPDATING_RATE_PER_HOUR']
elif action == 'Confirm':
pids_count = find_registered_doi_pids(from_date,
until_date,
current_app.config['ZENODO_LOCAL_DOI_PREFIXES']).count()
task_details = dict(
start_date=datetime.utcnow(),
job_id=str(uuid.uuid4()),
from_date=from_date,
until_date=until_date,
total_pids=pids_count,
left_pids=pids_count,
last_update=datetime.utcnow()
)
current_cache.set('update_datacite:task_details',
task_details, timeout=-1)
return redirect(url_for('updatedataciteview.update_datacite'))
elif action == 'Cancel':
return redirect(url_for('updatedataciteview.update_datacite'))
return self.render('zenodo_records/update_datacite.html',
form=form,
cancel_or_new_task_form=cancel_or_new_task_form,
details=task_details,
is_task_running=is_task_running, time=time)
def delete(id):
item = Transcript.query.get_or_404(id)
form = FlaskForm()
if form.validate_on_submit():
db.session.delete(item)
db.session.commit()
return redirect_for('transcript.index')
return render_template('transcript/delete.html', item=item, form=form)
def delete(id):
item = Salad.query.get_or_404(id)
form = FlaskForm()
if form.validate_on_submit():
item.delete()
db.session.commit()
return redirect_for('salad.index')
return render_template('salad/delete.html', item=item, form=form)
def email_verification_request():
"""GET|POST /email-verification-request: handle email verification requests
"""
u = g.user
form = FlaskForm()
if form.validate_on_submit():
send_verification_email(u)
fn = '/auth/email-verification-request-followup.html'
return render_template(fn, email=u.email)
return render_template('/auth/email-verification-request.html', form=form)
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if len(str(self.postalcode.data)) is 5 and int(self.postalcode.data):
return True
self.postalcode.data = re.sub(r'\s', r'', self.postalcode.data)
if not len(str(self.postalcode.data)) is 6:
self.postalcode.errors.append('Invalid postal code (length)')
return False
if not ''.join([
str(self.postalcode.data)[0],
str(self.postalcode.data)[2],
str(self.postalcode.data)[4]
]).isalpha():
self.postalcode.errors.append(
'Invalid postal code (example: A1A1A1)'
)
return False
if not ''.join([
str(self.postalcode.data)[1],
str(self.postalcode.data)[3],
str(self.postalcode.data)[5]
]).isdigit():
self.postalcode.errors.append(
'Invalid postal code (example: A1A1A1)'
)
return False
return True
def validate(self):
# Validate all other fields with default validators
if not FlaskForm.validate(self):
return False
result = True
archive_date = self.archive_date.data
publish_date = self.publish_date.data
if archive_date and publish_date > archive_date:
self.archive_date.errors.append(
_('Archive date needs to be after the publish date.'))
result = False
# Test if either english or dutch is entered
if not (self.nl_title.data or self.en_title.data):
self.nl_title.errors.append(
_('Either Dutch or English title required'))
result = False
if not (self.nl_content.data or self.en_content.data):
self.nl_content.errors.append(
_('Either Dutch or English content required'))
result = False
# XOR the results to test if both of a language was given
if bool(self.nl_title.data) != bool(self.nl_content.data):
self.nl_title.errors.append(
_('Dutch title requires Dutch content and vice versa'))
result = False
if bool(self.en_title.data) != bool(self.en_content.data):
self.en_title.errors.append(
_('English title requires English content and vice versa'))
result = False
return result
def validate(self):
rv = FlaskForm.validate(self)
if rv is None:
return False
user = authenticate_user(current_user.username, self.password.data)
if user is None:
return False
return True
def validate(self): if not Form.validate(self): return False if self.username.data == self.original_username: return True user = User.query.filter_by(username = self.username.data).first() if user != None: return False return True
def validate(self):
if not FlaskForm.validate(self):
return False
user = User.query.filter_by(email = self.email.data.lower()).first()
if user:
self.email.errors.append("That email is already taken")
return False
else:
return True
def validate(self):
if not FlaskForm.validate(self):
return False
if self.open.data:
self.desired_state = DoorState.Open
elif self.present.data:
self.desired_state = DoorState.Present
return True
def validate(self):
if not FlaskForm.validate(self):
return False
user = User.query.filter_by(email = self.email.data.lower()).first()
if user and user.check_password(self.password.data):
return True
else:
self.email.errors.append("Invalid e-mail or password")
return False
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.get_user(self.username.data)
if user and user.username.lower() != g.user.username.lower():
self.username.errors.append('Username already in use')
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if rv is None:
return False
user = User.objects(username__iexact=self.username.data).first()
if user is None:
return True
else:
self.username.errors.append("Username is already taken - try again")
return False
def validate(self):
rv = FlaskForm.validate(self)
if rv is None:
return False
user = authenticate_user(self.username.data, self.password.data)
if user is None:
self.username.errors.append("Invalid username or password")
return False
else:
self.user = user
return True
def validate(self):
rv = FlaskForm.validate(self)
config = ConfigParser.RawConfigParser()
config.read('swingflask.conf')
if (
self.username.data == config.get('admin', 'username')
and self.password.data == config.get('admin', 'password')
):
return True
else:
self.username.errors.append('Invalid credentials')
return False
def validate(self):
rv = Form.validate(self)
if not rv:
return False
captcha = session['captcha']
captcha_data = self.captcha.data
if captcha_data.lower() != captcha.lower():
self.captcha.errors.append(_('The captcha is error'))
return False
return True
def validate(self):
# check default validation
if not FlaskForm.validate(self):
return False
# check nested forms
for t in self.target_set:
if not t.form.validate():
error_fields = ','.join(t.form.errors.keys())
self.target_set.errors.append({'target': t.name, 'message': 'Invalid target ' + error_fields})
return False
return True
def validate(self):
if not FlaskForm.validate(self):
print "wrong two"
return False
user = User.query.filter_by(username=self.username.data).first()
if user and user.verify_password(self.password_hash.data):
return True
else:
flash('invalid username or password')
self.username.errors.append("Invalid username or password")
return False
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.query.filter_by(username=self.username.data).first()
if user and user.verify_password(self.password_hash.data):
print "login 1 working"
return True
else:
flash("Invalid username or password")
#self.username.errors.append("Invalid username or password")
return False
def validate(self):
# Validate all other fields with default validators
if not FlaskForm.validate(self):
return False
# Test if either english or dutch is entered
if self.start_time.data >= self.end_time.data:
self.start_time.errors.append(
_("Start time must be before end time"))
# Append empty string to mark the field red.
self.end_time.errors.append('')
return False
return True
def validate(self, *args, **kwargs):
"""
Validates the form by calling `validate` on each field, passing any
extra `Form.validate_<fieldname>` validators to the field validator.
also calls `validate_ldap`
"""
valid = FlaskForm.validate(self, *args, **kwargs)
if not valid:
logging.debug("Form validation failed before we had a change to "
"check ldap. Reasons: '{0}'".format(self.errors))
return valid
return self.validate_ldap()
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
print "hello worlkd"
username = User.query.filter(func.lower(User.username) == func.lower(self.username.data)).first()
if username:
self.username.errors.append("Invalid username or password")
flash('username taken')
return False
else:
print "Register Validate success"
return True
def validate(self):
if not FlaskForm.validate(self):
return False
if self.country_input_method.data == 'choose':
if place_exists(self.place.data, self.country.data.country_name):
flash(
f'Место {self.place.data} в {self.country.data.country_name} уже существует'
)
return False
if self.country_input_method.data == 'create':
if country_exists(self.new_country.data):
flash(f'Страна {self.new_country.data} уже существует')
return False
if self.new_country.data == '':
flash('Название страны - обязательно поле')
return False
return True
def validate(self) -> bool:
valid = FlaskForm.validate(self)
# Check date format, if valid put dates into a list called "dates"
dates = {}
for prefix in ['begin_', 'end_']:
for postfix in ['_from', '_to']:
if getattr(self, prefix + 'year' + postfix).data:
date = DateMapper.form_to_datetime64(
getattr(self, prefix + 'year' + postfix).data,
getattr(self, prefix + 'month' + postfix).data,
getattr(self, prefix + 'day' + postfix).data)
if not date:
getattr(self, prefix + 'day' + postfix).errors.append(
_('not a valid date'))
valid = False
else:
dates[prefix + postfix.replace('_', '')] = date
# Check for valid date combination e.g. begin not after end
if valid:
for prefix in ['begin', 'end']:
if prefix + '_from' in dates and prefix + '_to' in dates:
if dates[prefix + '_from'] > dates[prefix + '_to']:
field = getattr(self, prefix + '_day_from')
field.errors.append(
_('First date cannot be after second.'))
valid = False
if valid and 'begin_from' in dates and 'end_from' in dates:
field = getattr(self, 'begin_day_from')
if len(dates) == 4: # All dates are used
if dates['begin_from'] > dates['end_from'] or dates[
'begin_to'] > dates['end_to']:
field.errors.append(
_('Begin dates cannot start after end dates.'))
valid = False
else:
first = dates['begin_to'] if 'begin_to' in dates else dates[
'begin_from']
second = dates['end_from'] if 'end_from' in dates else dates[
'end_to']
if first > second:
field.errors.append(
_('Begin dates cannot start after end dates.'))
valid = False
return valid
def validate (self):
if self.url.data.startswith("http://") == False and self.url.data.startswith("https://") == False :
self.url.data = "http://" + self.url.data
if not FlaskForm.validate(self):
return False
if not self.description.data:
self.description.data = self.url.data
#fliter for empty and duplicate tags
stripped = [t.strip() for t in self.tags.data.split(',')]
not_empty = [tag for tag in stripped if tag]
tagset = set(not_empty)
self.tags.data = ",".join(tagset)
return True
def validate(self):
"""
Checks if user exists already (by email)
:return: If the user exists already, return False, else True
"""
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append("This email is already taken.")
return False
return True
def hidden_tag_without(self, *exclude_fields):
""" Return the hidden fields for this form, excluding the fields listed in
`exclude_fields`
We use this to render all the hidden fields in the form except for the
CSRF token, for reasons which are currently unclear to me.
"""
fields = [
getattr(self, f)
if isinstance(f, string_types) and hasattr(self, f) else f
for f in exclude_fields
]
keep_fields = [
f for f in self
if isinstance(f.widget, HiddenInput) and f not in fields
]
return FlaskForm.hidden_tag(self, *keep_fields)
def validate_location(form):
'''Overrides the default validation for the form
by running it first, then ensuring that the location
and participant are not both empty for an incident
form'''
result = FlaskForm.validate(form)
if not result:
return result
if not form.participant.data and not form.location.data:
form.location.errors.append(
_('Participant and location cannot both be empty'))
form.participant.errors.append(
_('Participant and location cannot both be empty'))
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
proizvod = Proizvod.query.get(self.proizvod_id.data)
if proizvod.kolicina < self.promijenjena_kolicina.data:
self.promijenjena_kolicina.errors.append(
'Nema dovoljno artikla na stanju')
return False
tvrtka = Tvrtka.query.filter_by(name=self.name.data).first()
if tvrtka is None:
self.name.errors.append('Tvrtka ne postoji')
return False
else:
return True
def validate(self):
# validate form submission
rv = FlaskForm.validate(self)
if not rv:
return False
# try to get valid user
user = User.query.filter_by(username=self.username.data).first()
if user is None:
self.username.errors.append('Unknown username')
return False
if not user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
self.user = user
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = auth_get_user_by_email(self.email.data)
if user:
self.password.errors.append('Email already registered')
return False
if len(self.password.data) < 8:
self.password.errors.append(
'Password should be at least 8 characters long')
return False
self.user = auth_add_user(self.email.data, self.password.data)
return True
def validate(self):
if not FlaskForm.validate(self):
return False
if self.name.data and self.password.data and self.role.data:
from peerplaysbase.account import PasswordKey
pkey = PasswordKey(self.name.data, self.password.data, self.role.data)
self.privateKey.data = pkey.get_private_key()
if self.privateKey.data:
try:
Node().validateAccount(self.privateKey.data),
return True
except Exception:
self.privateKey.errors.append("No account connected to this private key")
return False
else:
return False
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
account = get_account(self.email.data)
if account is None:
self.email.errors.append('This email is not registered.')
return False
if not account.check_password(self.password.data):
self.password.errors.append('Incorrect password.')
return False
self.account = account
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = Users.query.filter_by(usersname=self.username.data).first()
if user:
self.email.errors.append('Email already taken')
return False
email = Users.query.filter_by(email=self.email.data).first()
if email:
self.email.errors.append('Account already created with this email')
return False
self.user = user
return True
def validate(self):
if not self.url.data.startswith("http://") or \
self.url.data.startswith("https://"):
self.url.data = "http://" + self.url.data
if not Form.validate(self):
return False
if not self.description.data:
self.description.data = self.url.data
#filter out empty and duplicates tag names
stripped = [t.strip() for t in self.tags.data.split(',')]
not_empty = [tag for tag in stripped if tag]
tagset = set(not_empty)
self.tags.data = ",".join(tagset)
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append(gettext('Username already registered'))
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append(gettext('Email already registered'))
return False
self.user = user
return True
def validate(self):
self.user = None
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.get_user(self.username.data)
if user is None:
self.username.errors.append('Unknown username')
return False
if not user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
self.user = user
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = Users.query.filter_by(
email=self.email.data
).first()
if user:
if not check_password_hash(user.password, self.password.data):
self.password.errors.append('Incorrect email or password')
return False
return True
else:
self.password.errors.append('Incorrect email or password')
return False
def validate(self):
if not (self.url.data.startswith('http://')
or self.url.data.startswith('https://')):
self.url.data = 'http://' + self.url.data
if not FlaskForm.validate(self):
return False
if not self.description.data:
self.description.data = self.url.data
stripped = [t.strip() for t in self.tags.data.split(',')]
not_empty = [tag for tag in stripped if tag]
tag_set = set(not_empty)
self.tags.data = ','.join(tag_set)
return True
def validate(self):
# Python 3 use super().validate()
# Validate with the original validators first
if not FlaskForm.validate(self):
return False
result = True
# With snmp version 2 community should be set
if self.snmp_version.data == '2' and self.community.data == '':
self.community.errors.append('Community cannot be empty!')
result = False
if self.snmp_version.data == '3':
# With snmp version 3 security level and username should be always set
if self.security_username.data == '' or self.security_level.data == 'Choose...':
self.security_level.errors.append(
'Security Username and/or Security Level cannot be empty!')
self.security_username.errors.append(
'Security Username and/or Security Level cannot be empty!')
result = False
# With snmp version 3 and auth without priv auth protocol and auth password should be set
if self.security_level.data == 'auth_without_privacy':
if self.auth_protocol.data == 'Choose...' or self.auth_password.data == '':
self.auth_password.errors.append(
'With Auth without Privacy, Auth Prot and/or Auth Pwd cannot be empty'
)
self.auth_protocol.errors.append(
'With Auth without Privacy, Auth Prot and/or Auth Pwd cannot be empty'
)
result = False
# With snmp version 3 and auth with priv everything should be set
if self.security_level.data == 'auth_with_privacy':
if self.auth_protocol.data == 'Choose...' or self.auth_password.data == '' or \
self.privacy_protocol.data == 'Choose...' or self.privacy_password.data == '':
self.auth_password.errors.append(
'With Auth with Privacy, No Field can be empty')
self.auth_protocol.errors.append(
'With Auth with Privacy, No Field can be empty')
self.privacy_protocol.errors.append(
'With Auth with Privacy, No Field can be empty')
self.privacy_password.errors.append(
'With Auth with Privacy, No Field can be empty')
result = False
return result
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
import requests
req_string = "https://www.instagram.com/%s"
req = requests.get(req_string % (self.insta_username.data))
if req.status_code != 200:
self.insta_username.errors.append('User %s does not exist' %
self.insta_username.data)
return False
for page in self.pages.data:
req = requests.get(req_string % (page))
if req.status_code != 200:
self.pages.errors.append('Page %s does not exist' % page)
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if self.start_date.data and self.end_date.data:
start_date, _ = parseDateAccuracy(self.start_date.data)
end_date, _ = parseDateAccuracy(self.end_date.data)
if end_date < start_date:
self.end_date.errors.append(
'End date is before the start date')
if self.errors:
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if self.action.data not in ('edit', 'new'):
return False
has_error = False
if self.action.data in ('edit', 'new'):
if (not isinstance(self.name.data, string_types)) or not re.search(r'[A-Za-z0-9]', self.name.data):
self.name.errors.append(word("The name must be filled in."))
has_error = True
if (not isinstance(self.method.data, string_types)) or self.method.data not in ('referer', 'ip', 'none'):
self.name.errors.append(word("You must select an option."))
has_error = True
if has_error:
return False
return True
def validate(self):
if not FlaskForm.validate(self):
return False
# Cannot allow this Organization name, because it would cause issues on backend
if self.organization_name.data == 'global':
self.organization_name.errors.append(
'Cannot allow this Organization name for secret reasons, shush.'
)
return False
# TODO: remove these uniqueness checks after introduction of unique constraint
# in ETCD storage class on backend
client = get_service_client()
# Check if organization exists on backend
response = client.organization.list()
if response.status > 200:
self.organization_name.errors.append(
'Can not contact backend at this time.')
return False
organizations = response.data
organization_names = [org['name'] for org in organizations]
organization_namespaces = [o['namespace'] for o in organizations]
if self.organization_name.data in organization_names or slugify(
self.organization_name.data) in organization_namespaces:
self.organization_name.errors.append(
'Organization {} already exists.'.format(
self.organization_name.data))
return False
# Check if e-mail and username exists on backend
response = client.user.list()
if response.status > 200:
self.email.errors.append('Can not contact backend at this time.')
return False
users = response.data
user_emails = [u['email'] for u in users if 'email' in u]
if self.email.data in user_emails:
self.email.errors.append('This e-mail is already registered.')
return False
user_usernames = [u['username'] for u in users]
if self.email.data in user_usernames:
self.email.errors.append('This username is already registered.')
return False
return True
def validate(self):
if not BaseForm.validate(self):
return False
if self.nickname.data == self.original_nickname:
return True
if self.nickname.data != User.make_valid_nickname(self.nickname.data):
self.nickname.errors.append(
'This nickname has invalid characters. Please use letters, numbers, dots and underscores only')
return False
usr = User.query.filter_by(nickname=self.nickname.data).first()
if usr:
self.nickname.errors.append('This nickname is already in use. Please choose another one')
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if not is_safe_url(self.next.data):
return False
user = db.session.query(User).filter_by(
first_name=self.first_name.data,
last_name=self.last_name.data).one_or_none()
if user is None:
flash('''Such user doesn't exist''', 'danger')
return False
self.user = user
return True
def validate(self):
validInput = FlaskForm.validate(self)
if not validInput:
return False
accName = self.accName.data
password = self.password.data
if self.accType.data == 'FlatAcc':
accQuery = "SELECT account.acc_name, account.owner_name, account.flat_id, society.society_name, society.society_id FROM account \
INNER JOIN flat ON account.flat_id=flat.flat_id \
INNER JOIN wing ON flat.wing_id=wing.wing_id \
INNER JOIN society ON wing.society_id=society.society_id \
WHERE acc_name = '%s' && acc_pass = '******'" % (accName, password)
# ADMIN TABLE HAS A PASSWORD FIELD, BUT WE ARE CHECKING PASSWORD FROM ACCOUNT TABLE
elif self.accType.data == 'AdminAcc':
accQuery = 'SELECT acc_name, society_id, resident_id \
FROM admin \
WHERE acc_name="%s" && admin_pass = "******"' % (accName, password)
CURSOR.execute(accQuery)
if CURSOR.rowcount <= 0:
flash('INVALID LOGIN DETAILS')
return False
currUser = CURSOR.fetchone()
if self.accType.data == 'FlatAcc':
session['mainPage'] = '/dashboard'
session['accName'] = currUser[0]
session['ownerName'] = currUser[1]
session['flatId'] = currUser[2]
session['societyName'] = currUser[3]
session['societyId'] = currUser[4]
else:
session['mainPage'] = '/admin'
session['accName'] = currUser[0]
session['societyId'] = currUser[1]
societyAdminQuery = "SELECT society_name FROM society WHERE society_id=%d" % (session['societyId'])
CURSOR.execute(societyAdminQuery)
session['societyName'] = CURSOR.fetchone()[0]
session['ownerName'] = currUser[0]
return True
def validate(self):
rv = FlaskForm.validate(self)
print(projectID)
if not rv:
return False
if int(projectID)!=0:
project1 = Project.query.get_or_404(int(projectID))
project2 = Project.query.filter_by(name=self.name.data,version=self.version.data).first()
if project2 and (project1.name!=self.name.data or project1.version!=self.version.data):
self.name.errors.append('Mobile project was existed with %s-%s'%(self.name.data,self.version.data))
return False
else:
project = Project.query.filter_by(name=self.name.data,version=self.version.data).first()
if project:
self.name.errors.append('Mobile project was existed with %s-%s'%(self.name.data,self.version.data))
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
if self.action.data not in ('edit', 'new'):
return False
has_error = False
if self.action.data in ('edit', 'new'):
if type(self.name.data) not in (str, unicode) or not re.search(r'[A-Za-z0-9]', self.name.data):
self.name.errors.append(word("The name must be filled in."))
has_error = True
if type(self.method.data) not in (str, unicode) or self.method.data not in ('referer', 'ip', 'none'):
self.name.errors.append(word("You must select an option."))
has_error = True
if has_error:
return False
return True
def update_materia(id_materia):
rm = RepositorioMateria()
rc = RepositorioCurso()
if request.method == "GET":
cursos = rc.get_all()
materia = rm.get_one(int(id_materia))
if not materia:
return "Error: materia no encontrada. id_materia: " + str(
id_materia)
form = FlaskForm()
return render_template("nueva_materia.html",
mensaje=None,
form=form,
materia=materia,
cursos=cursos)
else:
# Capturar los datos del request
idm = request.form["id_materia"]
nombre = request.form["nombre"]
id_curso = request.form["curso"]
docente = request.form["docente"]
mail = request.form["mail"]
if request.form.get("sticky"):
sticky = True
else:
sticky = False
if request.form.get("cambiar_logo"):
logo = request.form["logo"]
else:
logo = None
rc = RepositorioCurso()
curso = rc.get_one(id_curso)
materia = Materia(idm, nombre, curso, logo, sticky, docente, mail)
#HACER EL UPDATE
if materia.logo:
resultado = rm.update(materia)
else:
resultado = rm.update(materia, cambiar_logo=False)
if resultado:
mensaje = "Datos de la materia modificados"
else:
mensaje = "Error al modificar los datos de la materia"
#Redirigir a cursos:
return redirect(url_for('materias', mensaje=mensaje))
def validate(self):
"""
custom validation method
:return: boolean
"""
result = True
if not FlaskForm.validate(self):
result = False
if not self.comm.data and not self.extcomm.data and not self.larcomm.data:
err_message = "At last one of those values could not be empty"
self.comm.errors.append(err_message)
self.larcomm.errors.append(err_message)
self.extcomm.errors.append(err_message)
result = False
return result
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
try:
participant = Participant.get(
Participant.Email == self.Email.data.lower().strip())
print(participant.Name, self.Name.data)
if participant.Name != self.Name.data.strip():
self.Name.errors.append(
'This name / email combination has already been used, contact [email protected] for help'
)
return False
else:
return True
except peewee.DoesNotExist:
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.query.filter_by(email=self.email.data).first()
if user is not None:
error = 'Email already in use'
self.email.errors.append(error)
print("ERROR: %s" % error)
return False
user = User(username=self.username.data, email=self.email.data)
user.password = self.password.data
self.user = user
return True
def validate(self):
# check default validation
if not FlaskForm.validate(self):
return False
# check nested forms
for t in self.target_set:
if not t.form.validate():
error_fields = ','.join(t.form.errors.keys())
self.target_set.errors.append({
'target':
t.name,
'message':
'Invalid target ' + error_fields
})
return False
return True
def validate(self):
rv = FlaskForm.validate(self)
if not rv:
return False
user = User.get_user(self.username.data)
if user and user.username.lower() != g.user.username.lower():
self.username.errors.append('Username already in use')
return False
if self.password.data:
if self.old_password.data == '':
self.old_password.errors.append('Please enter your old password')
return False
elif not user.check_password(self.old_password.data):
self.old_password.errors.append('Incorrect password')
return False
return True
def hidden_tag(self, *args, **kwargs):
self.form_name.data = self._form_name
return FlaskForm.hidden_tag(self, *args, **kwargs)
def is_submitted(self):
return FlaskForm.is_submitted(self) and request.form.get("form_name") == self._form_name
def __init__(self, *args, **kwargs):
self._form_name = type(self).__name__
FlaskForm.__init__(self, *args, **kwargs)
def __init__(self, default_license_id='CC BY-SA 3.0', default_language='en', **kwargs):
kwargs.setdefault('license_choice', default_license_id)
kwargs.setdefault('language', default_language)
FlaskForm.__init__(self, **kwargs)
