def sign_up():
"""Sign-up request."""
if flask_login.current_user.is_authenticated:
session['logged_in'] = True
return redirect(url_for('ramp.problems'))
form = UserCreateProfileForm()
if form.validate_on_submit():
user = add_user(session=db.session,
name=form.user_name.data,
password=form.password.data,
lastname=form.lastname.data,
firstname=form.firstname.data,
email=form.email.data,
linkedin_url=form.linkedin_url.data,
twitter_url=form.twitter_url.data,
facebook_url=form.facebook_url.data,
google_url=form.google_url.data,
github_url=form.github_url.data,
website_url=form.website_url.data,
bio=form.bio.data,
is_want_news=form.is_want_news.data,
access_level='asked')
admin_users = User.query.filter_by(access_level='admin')
for admin in admin_users:
subject = 'Approve registration of {}'.format(
encode_string(user.name))
body = body_formatter_user(user)
url_approve = ('http://www.ramp.studio/sign_up/{}'.format(
encode_string(user.name)))
body += 'Click on the link to approve the registration '
body += 'of this user: {}'.format(url_approve)
send_mail(admin.email, subject, body)
return redirect(url_for('auth.login'))
return render_template('sign_up.html', form=form)
def __repr__(self):
return ("User(name={}, lastname={}, firstname={}, email={}, "
"admined_teams={})".format(encode_string(self.name),
encode_string(self.lastname),
encode_string(self.firstname),
encode_string(self.email),
self.admined_teams))
def body_formatter_user(user):
"""Create the body of an email using the user information.
Parameters
----------
user : :class:`ramp_database.model.User`
The user profile.
Returns
-------
body : str
The email body.
"""
body = """
user = {}
name = {} {}
email = {}
linkedin = {}
twitter = {}
facebook = {}
github = {}
notes = {}
bio = {}
""".format(encode_string(user.name), encode_string(user.firstname),
encode_string(user.lastname), user.email, user.linkedin_url,
user.twitter_url, user.facebook_url, user.github_url,
encode_string(user.hidden_notes), encode_string(user.bio))
return body
def test_encode_string():
if six.PY3:
string = encode_string('a string')
assert isinstance(string, bytes)
string = encode_string(b'a string')
assert isinstance(string, bytes)
else:
string = encode_string('a string')
assert isinstance(string, bytes)
def test_problem_model(session_scope_module):
problem = get_problem(session_scope_module, 'iris')
assert (repr(problem) ==
"Problem({})\nWorkflow(Classifier)\n\tWorkflow(Classifier): "
"WorkflowElement(classifier)".format(encode_string('iris')))
# check that we can access the problem module and that we have one of the
# expected function there.
assert hasattr(problem.module, 'get_train_data')
assert problem.title == 'Iris classification'
assert issubclass(problem.Predictions, BasePrediction)
X_train, y_train = problem.get_train_data()
assert X_train.shape == (120, 4)
assert y_train.shape == (120, )
X_test, y_test = problem.get_test_data()
assert X_test.shape == (30, 4)
assert y_test.shape == (30, )
gt_train = problem.ground_truths_train()
assert hasattr(gt_train, 'label_names')
assert gt_train.y_pred.shape == (120, 3)
gt_test = problem.ground_truths_test()
assert hasattr(gt_test, 'label_names')
assert gt_test.y_pred.shape == (30, 3)
gt_valid = problem.ground_truths_valid([0, 1, 2])
assert hasattr(gt_valid, 'label_names')
assert gt_valid.y_pred.shape == (3, 3)
assert isinstance(problem.workflow_object, Classifier)
def test_event_team_model(session_scope_module):
event = get_event(session_scope_module, 'iris_test')
team = get_team_by_name(session_scope_module, 'test_user')
event_team = (session_scope_module.query(EventTeam).filter(
EventTeam.event_id == event.id).filter(
EventTeam.team_id == team.id).one())
assert repr(event_team) == "Event(iris_test)/Team({})".format(
encode_string('test_user'))
def sign_up_for_event(event_name):
"""Landing page to sign-up to a specific RAMP event.
Parameters
----------
event_name : str
The name of the event.
"""
event = get_event(db.session, event_name)
if not is_accessible_event(db.session, event_name,
flask_login.current_user.name):
return redirect_to_user(u'{}: no event named "{}"'.format(
flask_login.current_user.firstname, event_name))
if app.config['TRACK_USER_INTERACTION']:
add_user_interaction(db.session,
interaction='signing up at event',
user=flask_login.current_user,
event=event)
ask_sign_up_team(db.session, event.name, flask_login.current_user.name)
if event.is_controled_signup:
admin_users = User.query.filter_by(access_level='admin')
for admin in admin_users:
subject = ('Request to sign-up {} to RAMP event {}'.format(
event.name, flask_login.current_user.name))
body = body_formatter_user(flask_login.current_user)
url_approve = (
'https://www.ramp.studio/events/{}/sign_up/{}'.format(
event.name, encode_string(flask_login.current_user.name)))
body += ('Click on this link to approve the sign-up request: {}'.
format(url_approve))
send_mail(admin, subject, body)
return redirect_to_user("Sign-up request is sent to event admins.",
is_error=False,
category='Request sent')
sign_up_team(db.session, event.name, flask_login.current_user.name)
return redirect_to_sandbox(event,
u'{} is signed up for {}.'.format(
flask_login.current_user.firstname, event),
is_error=False,
category='Successful sign-up')
def __str__(self):
return 'User({})'.format(encode_string(self.name))
def __repr__(self):
return 'Problem({})\n{}'.format(encode_string(self.name),
self.workflow)
def __repr__(self):
return (
'Team(name={}, admin_name={}, initiator={}, acceptor={})'.format(
encode_string(self.name), encode_string(self.admin.name),
self.initiator, self.acceptor))
def __repr__(self):
return 'ScoreType(name={})'.format(encode_string(self.name))
