def judge_(self, grade=None, comment=None, corrected_source=None, annotations=None, **kwargs):
self._judge_permissions()
judgement_annotations = dict()
if annotations:
keyfunc = lambda d: d['line']
for k, g in groupby(sorted(annotations, key=keyfunc), key=keyfunc):
judgement_annotations[k] = ', '.join((d['comment'] for d in g))
judgement_attrs = dict(
grade=grade, comment=comment, corrected_source=corrected_source,
annotations=judgement_annotations or None,
)
if any((True for x in judgement_attrs.itervalues() if x is not None)):
# Judgement is not empty
judgement = self.submission.judgement or Judgement(submission=self.submission)
judgement.tutor = request.user
judgement.date = datetime.now()
for k in judgement_attrs:
setattr(judgement, k, judgement_attrs[k])
else:
# Judgement is empty
judgement = None
self.submission.judgement = judgement
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Submission %d, judgement could not be saved:', self.submission.id, exc_info=True)
flash('Error saving judgement', 'error')
redirect(self.submission.url + '/judge')
def setUp(self):
super(TestEnrolling, self).setUp()
self.user = User(user_name='studentxxx',
display_name='Student XXX',
email_address='*****@*****.**')
DBSession.add(self.user)
transaction.commit()
self.extra_environ = dict(REMOTE_USER=self.user.user_name)
def test_enroll_event(self):
"""Enrolling for Event"""
demo = self.configure_event('demo', 'event', None)
response = self.app.get('/events/demo/enroll', extra_environ=self.extra_environ)
response = response.follow()
response.mustcontain('Enrolled for Event', 'Programming 101 - Demo')
user = DBSession.merge(self.user)
demo = DBSession.merge(demo)
assert user in demo.members
assert demo in user._events
def run_tests(self):
compilation = None
testruns = []
result = False
# Consistency checks
if self.language and self.source and self.assignment:
with Runner(self) as r:
log.debug('Starting Runner for submission %d' % self.id)
# First compile, if needed
compilation = r.compile()
if compilation:
log.debug('Compilation runtime: %f' % compilation.runtime)
log.debug('Compilation result: %s' % compilation.result)
if not compilation or compilation.result:
# Delete old testruns
self.testruns = []
#DBSession.flush()
# Then run all the tests
testruns = []
start = time()
for t in r.test():
testruns.append(t)
self.testruns.append(
Testrun(
submission=self,
test=t.test,
result=t.result,
partial=t.partial,
runtime=t.runtime,
output_data=t.output_data,
error_data=t.error_data,
))
end = time()
test_time = end - start
log.debug('Test runs total runtime: %f' % test_time)
log.debug('Test runs results: %s' %
', '.join(str(t.result) for t in testruns))
try:
DBSession.flush()
except:
log.exception('Could not save testrun results')
raise
result = self.result
log.debug('Test runs result: %s ' % result)
else:
log.debug('Test runs not run')
return (compilation, testruns, result)
def test_enroll_event(self):
"""Enrolling for Event"""
demo = self.configure_event('demo', 'event', None)
response = self.app.get('/events/demo/enroll',
extra_environ=self.extra_environ)
response = response.follow()
response.mustcontain('Enrolled for Event', 'Programming 101 - Demo')
user = DBSession.merge(self.user)
demo = DBSession.merge(demo)
assert user in demo.members
assert demo in user._events
def test_integration_2(self):
test = Test(
assignment_id=42,
output_data=u'42 Bananas\n4711 Strawberrys\n1337 Apples\n',
splitlines=True, sort=True,
)
DBSession.add(test)
DBSession.flush()
test = DBSession.merge(test)
d = u'#Result:\n4711 Strawberrys\n42 Bananas\n1337 Apples\n'
result, _, expected, output, _ = test.validate(d)
converted_output = test.unconvert(test.convert(d))
assert result is True, (expected, output, converted_output)
def run_tests(self):
compilation = None
testruns = []
result = False
# Consistency checks
if self.language and self.full_source and self.assignment:
with Runner(self) as r:
log.debug('Starting Runner for submission %r', self)
# First compile, if needed
compilation = r.compile()
if compilation:
log.debug('Compilation runtime: %f', compilation.runtime)
log.debug('Compilation result: %s', compilation.result)
if not compilation or compilation.result:
# Delete old testruns
self.testruns = []
#DBSession.flush()
# Then run all the tests
testruns = []
start = time()
for t in r.test():
testruns.append(t)
self.testruns.append(
Testrun(
submission=self, test=t.test,
result=t.result, partial=t.partial,
runtime=t.runtime,
output_data=t.output_data,
error_data=t.error_data,
)
)
end = time()
test_time = end - start
log.debug('Test runs total runtime: %f', test_time)
log.debug('Test runs results: %r', list(str(t.result) for t in testruns))
try:
DBSession.flush()
except:
log.exception('Could not save testrun results')
raise
result = self.result
log.debug('Test runs result: %s ', result)
else:
log.debug('Test runs not run')
return (compilation, testruns, result)
def test_integration_1(self):
test = Test(
assignment_id=42,
output_data=u'1.0,2.0,3.0\n4.0,5.0,6.0\n7.0,8.0,9.0\n',
separator=',', split=True, splitlines=True,
parse_float=True, float_precision=1,
)
DBSession.add(test)
DBSession.flush()
test = DBSession.merge(test)
d = u'#Result:\n1,2,3\n4,5,6\n,7,8,9\n'
result, _, expected, output, _ = test.validate(d)
converted_output = test.unconvert(test.convert(d))
assert result is True, (expected, output, converted_output)
def main():
args = parse_args()
load_config(args.conf_file)
#print model.DBSession.query(model.User.user_name).all()
events = Session.query(model.Event).all()
print[(i, e.name) for i, e in enumerate(events)]
event_id = raw_input('event_id: ')
event = events[int(event_id)]
fix_languages = raw_input("Allow all languages on all assignments? [y]")
if fix_languages == 'y':
l = Session.query(model.Language).all()
for a in Session.query(
model.Assignment).filter_by(event_id=event.id).all():
a = Session.merge(a)
a.allowed_languages = l
Session.add(a)
try:
transaction.commit()
except IntegrityError:
print traceback.format_exc()
transaction.abort()
fix_visible_tests = raw_input(
"Fix boolean visible attribute on tests? [y]")
if fix_visible_tests == 'y':
for a in Session.query(
model.Assignment).filter_by(event_id=event.id).all():
a = Session.merge(a)
print u'Assignment: %s' % a.name
for t in a.tests:
print u'Test %d, Output length %d' % (t.id, len(t.output))
visible = raw_input('Make test visible? [y]')
if visible == 'y':
t.visible = True
Session.add(t)
try:
transaction.commit()
except IntegrityError:
print traceback.format_exc()
transaction.abort()
def _test_attr(args):
kwargs, expected_output_data, good_output_data = args[0:3]
bad_output_data = args[4:]
test = Test(assignment_id=42, output_data=expected_output_data, **kwargs)
DBSession.add(test)
DBSession.flush()
test = DBSession.merge(test)
for d in good_output_data:
result, _, expected, output, _ = test.validate(d)
converted_output = test.unconvert(test.convert(d))
assert result is True, (expected, output, converted_output)
for d in bad_output_data:
result, _, expected, output, _ = test.validate(d)
converted_output = test.unconvert(test.convert(d))
assert result is False, (expected, output, converted_output)
def index(self):
assignment_query = DBSession.query(Assignment)
submission_query = DBSession.query(Submission).join(Assignment)
team_query = DBSession.query(Team)
if self.event_id:
assignment_query = assignment_query.filter(
Assignment.event_id == self.event_id)
submission_query = submission_query.filter(
Assignment.event_id == self.event_id)
#team_query = team_query.join(team_to_event).filter_by(event_id=self.event_id)
teams = team_query.all()
for team in teams:
team.score = 0
team.count = 0
team.assignments = []
for assignment in assignment_query.all():
assignment.done = {}
assignment.solution = {}
for submission in (submission
for submission in assignment.submissions
if submission.result is not None):
try:
assert submission.team in teams
if not assignment.done.get(submission.team.id):
if submission.testrun.result:
submission.team.score += int(
(submission.testrun.date -
assignment.start_time).seconds / 60)
submission.team.count += 1
assignment.done[submission.team.id] = True
assignment.solution[
submission.team.id] = submission
submission.team.assignments.append(assignment)
else:
submission.team.score += penalty
except Exception as e:
log.warn('Error in submission %d: %s' % (submission.id, e))
teams = sorted(sorted(teams, key=lambda team: team.score),
key=lambda team: team.count,
reverse=True)
return dict(page='scores', event=self.event, teams=teams)
def post(self, *args, **kwargs):
'''Process form data into user profile'''
if config.features.get('externalauth', False): # pragma: no cover
flash(
'Profile changes are not possible because external authentication is used!',
'error')
redirect(url('/user/profile'))
user = DBSession.merge(request.user)
# try:
# d = User.query.filter_by(email_address=kwargs['email_address']).one()
# except:
# pass
# else:
# if d.user_name != request.user.user_name:
# flash('The email address "%s" is already registered!' % (kwargs['email_address']), 'error')
# redirect(url('/user/profile'))
try:
user._display_name = kwargs.get('display_name', '')
# user.first_name = kwargs['first_name']
# user.last_name = kwargs['last_name']
user.email_address = kwargs.get('email_address', '')
# Only attempt to change password if both values are set
if (kwargs.get('password_1', None) and kwargs.get(
'password_1', None) == kwargs.get('password_2', None)):
user.password = kwargs.get('password_1', '')
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warning('Error modifying profile of User %r',
user,
exc_info=True)
flash('Error modifying profile', 'error')
except:
log.warning('Error modifying profile of User %r',
user,
exc_info=True)
flash('Error modifying profile', 'error')
else:
flash('Profile modified', 'ok')
finally:
redirect(url('/user/profile'))
def main():
args = parse_args()
load_config(args.conf_file)
#print model.DBSession.query(model.User.user_name).all()
events = Session.query(model.Event).all()
print [(i, e.name) for i,e in enumerate(events)]
def main():
args = parse_args()
load_config(args.conf_file)
#print model.DBSession.query(model.User.user_name).all()
events = Session.query(model.Event).all()
print[(i, e.name) for i, e in enumerate(events)]
event_id = raw_input('event_id: ')
event = events[int(event_id)]
while True:
teamname = raw_input("Team-Name: ")
if not isinstance(teamname, unicode):
teamname = teamname.decode('utf-8')
password = getpass("Password: "******"Next Team? [y]")
if next != 'y':
break
def public(self, target=None, *args, **kwargs):
self._edit_permissions()
if target is not None:
# Set
target = asbool(target)
else:
# Toggle
target = not self.submission.public
self.submission.public = target
_url = getattr(request, 'referer', None) or self.submission.url
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Submission %r, could not change publicity status to %s',
self.submission, target, exc_info=True)
flash('Error changing publicity status to %s' % ('public' if target else 'private'), 'error')
finally:
flash('Changed publicity status to %s' % ('public' if target else 'private'), 'ok')
redirect(_url)
def edit_(self, language=None, source=None, filename=None, **kwargs):
self._edit_permissions()
log.info(dict(submission_id=self.submission.id,
assignment_id=self.assignment.id,
language=language, filename=filename, source=source))
#self.submission.assignment = self.assignment
#if request.student:
# self.submission.student = request.student
if self.submission.language != language:
self.submission.language = language
if self.submission.source != source:
self.submission.source = source
if self.submission.filename != filename:
self.submission.filename = filename
if self.submission in DBSession.dirty:
self.submission.modified = datetime.now()
DBSession.add(self.submission)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Submission %d could not be saved', self.submission.id, exc_info=True)
flash('Your submission could not be saved!', 'error')
redirect(self.submission.url + '/edit')
else:
redirect(self.submission.url + '/result')
def submit(self, *args, **kwargs):
'''Create new submission for this assignment'''
if 'manage' not in request.permissions and \
request.user not in set(self.event.members) | set(self.event.tutorsandteachers):
abort(403)
if (not self.assignment.is_active
and not request.allowance(self.assignment)):
flash(
'This assignment is not active, you may not create a submission',
'warning')
redirect(url(self.assignment.url))
submission = Submission(
assignment=self.assignment,
filename=self.assignment.submission_filename or None,
source=self.assignment.submission_template or None,
language=self.assignment.allowed_languages[0]
if self.assignment.allowed_languages else None,
user=request.user,
created=datetime.now(),
modified=datetime.now(),
)
DBSession.add(submission)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Error creating new submission', exc_info=True)
flash('Error creating new submission', 'error')
redirect(url(self.assignment.url))
else:
redirect(url(submission.url + '/edit'))
def submit(self, *args, **kwargs):
'''Create new submission for this assignment'''
if 'manage' not in request.permissions and \
request.user not in set(self.event.members) | set(self.event.tutorsandteachers):
abort(403)
if (not self.assignment.is_active and
not request.allowance(self.assignment)):
flash('This assignment is not active, you may not create a submission', 'warning')
redirect(url(self.assignment.url))
submission = Submission(
assignment=self.assignment,
filename=self.assignment.submission_filename or None,
source=self.assignment.submission_template or None,
language=self.assignment.allowed_languages[0] if self.assignment.allowed_languages else None,
user=request.user,
created=datetime.now(),
modified=datetime.now(),
)
DBSession.add(submission)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Error creating new submission', exc_info=True)
flash('Error creating new submission', 'error')
redirect(url(self.assignment.url))
else:
redirect(url(submission.url + '/edit'))
def post(self, *args, **kwargs):
'''Process form data into user profile'''
if config.features.get('externalauth', False): # pragma: no cover
flash('Profile changes are not possible because external authentication is used!', 'error')
redirect(url('/user/profile'))
user = DBSession.merge(request.user)
# try:
# d = User.query.filter_by(email_address=kwargs['email_address']).one()
# except:
# pass
# else:
# if d.user_name != request.user.user_name:
# flash('The email address "%s" is already registered!' % (kwargs['email_address']), 'error')
# redirect(url('/user/profile'))
try:
user._display_name = kwargs.get('display_name', '')
# user.first_name = kwargs['first_name']
# user.last_name = kwargs['last_name']
user.email_address = kwargs.get('email_address', '')
# Only attempt to change password if both values are set
if (kwargs.get('password_1', None) and
kwargs.get('password_1', None) == kwargs.get('password_2', None)):
user.password = kwargs.get('password_1', '')
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warning('Error modifying profile of User %r', user, exc_info=True)
flash('Error modifying profile', 'error')
except:
log.warning('Error modifying profile of User %r', user, exc_info=True)
flash('Error modifying profile', 'error')
else:
flash('Profile modified', 'ok')
finally:
redirect(url('/user/profile'))
def judge_(self, grade=None, comment=None, corrected_source=None, annotations=None,
public=None, *args, **kwargs):
self._judge_permissions()
judgement_annotations = None
if annotations:
key = lambda d: d['line']
judgement_annotations = dict(
(k, ', '.join((d['comment'] for d in g if d['comment'])))
for k, g in groupby(sorted(annotations, key=key), key=key)
)
judgement_attrs = dict(
grade=grade, comment=comment, corrected_source=corrected_source,
annotations=judgement_annotations or None, public=public,
)
if any((True for x in judgement_attrs.itervalues() if x is not None)):
# Judgement is not empty
judgement = self.submission.judgement or Judgement(submission=self.submission)
judgement.tutor = request.user
judgement.date = datetime.now()
for k in judgement_attrs:
setattr(judgement, k, judgement_attrs[k])
else:
# Judgement is empty
judgement = None
self.submission.judgement = judgement
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Submission %r, judgement could not be saved:', self.submission, exc_info=True)
flash('Error saving judgement', 'error')
redirect(self.submission.url + '/judge')
def test_enroll_lesson(self):
"""Enrolling for Lesson"""
demo = self.configure_event('demo', 'lesson', None)
response = self.app.get('/events/demo/enroll', extra_environ=self.extra_environ)
response.mustcontain('Lesson A/B', 'Lesson C/D', 'Lesson E')
response.form.set('lesson', 1)
response = response.form.submit(extra_environ=self.extra_environ)
user = DBSession.merge(self.user)
lesson = Lesson.query.filter_by(id=1).one()
assert user in lesson.members
assert lesson in user._lessons
def index(self):
assignment_query = DBSession.query(Assignment)
submission_query = DBSession.query(Submission).join(Assignment)
team_query = DBSession.query(Team)
if self.event_id:
assignment_query = assignment_query.filter(Assignment.event_id == self.event_id)
submission_query = submission_query.filter(Assignment.event_id == self.event_id)
#team_query = team_query.join(team_to_event).filter_by(event_id=self.event_id)
teams = team_query.all()
for team in teams:
team.score = 0
team.count = 0
team.assignments = []
for assignment in assignment_query.all():
assignment.done = {}
assignment.solution = {}
for submission in (submission for submission in assignment.submissions if submission.result is not None):
try:
assert submission.team in teams
if not assignment.done.get(submission.team.id):
if submission.testrun.result:
submission.team.score += int((submission.testrun.date - assignment.start_time).seconds / 60)
submission.team.count += 1
assignment.done[submission.team.id] = True
assignment.solution[submission.team.id] = submission
submission.team.assignments.append(assignment)
else:
submission.team.score += penalty
except Exception as e:
log.warn('Error in submission %d: %s' % (submission.id, e))
teams = sorted(sorted(teams, key=lambda team: team.score), key=lambda team: team.count, reverse=True)
return dict(page='scores', event=self.event, teams=teams)
def test_enroll_lesson(self):
"""Enrolling for Lesson"""
demo = self.configure_event('demo', 'lesson', None)
response = self.app.get('/events/demo/enroll',
extra_environ=self.extra_environ)
response.mustcontain('Lesson A/B', 'Lesson C/D', 'Lesson E')
response.form.set('lesson', 1)
response = response.form.submit(extra_environ=self.extra_environ)
user = DBSession.merge(self.user)
lesson = Lesson.query.filter_by(id=1).one()
assert user in lesson.members
assert lesson in user._lessons
def index(self, *args, **kwargs):
try:
server = oauth2.Server()
server.add_signature_method(oauth2.SignatureMethod_HMAC_SHA1())
req = oauth2.Request.from_request(request.method, request.url,
request.headers, request.params,
request.query_string)
params = server.verify_request(
req, oauth2.Consumer(self.key, self.secret), None)
except:
log.debug('LTI Tool Provider OAuth Error', exc_info=True)
flash('LTI Tool Provider OAuth Error', 'error')
abort(403)
else:
log.debug(params)
user_name = (
params.get('tool_consumer_info_product_family_code', 'external') +
'_' + params.get('tool_consumer_instance_guid', 'external') + '_' +
params.get('user_id'))
user = User.query.filter_by(user_name=user_name).first()
if not user:
log.info('New user %s', user_name)
user = User(
user_name=user_name,
display_name=params.get('lis_person_name_full'),
email_address=params.get('lis_person_contact_email_primary'),
)
DBSession.add(user)
submission = Submission.query.filter(
Submission.assignment == self.assignment,
Submission.user == user).first()
if not submission:
submission = Submission(
assignment=self.assignment,
filename=self.assignment.submission_filename or None,
source=self.assignment.submission_template or None,
language=self.assignment.allowed_languages[0],
user=user,
created=datetime.now(),
modified=datetime.now(),
)
DBSession.add(submission)
DBSession.flush()
session['lti'] = True
session['params'] = params
session['user'] = user.id
session['submission'] = submission.id
session.save()
redirect('/lti/%d/edit' % self.assignment.id)
def edit_(self, *args, **kwargs):
self._get_session_data()
v = SubmissionForm.validate(kwargs)
language = v['language']
source = v['source']
filename = v['filename']
self.submission.assignment = self.assignment
self.submission.user = self.user
if self.submission.language != language:
self.submission.language = language
if self.submission.source != source:
self.submission.source = source
if self.submission.filename != filename:
self.submission.filename = filename
if self.submission in DBSession.dirty:
self.submission.modified = datetime.now()
DBSession.add(self.submission)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Submission %r could not be saved',
self.submission,
exc_info=True)
flash('Your submission could not be saved!', 'error')
redirect('./edit')
else:
# redirect(self.submission.url + '/result')
pass
(compilation, testruns, result) = self.submission.run_tests()
testruns = sorted(set(self.submission.testruns), key=lambda s: s.date)
result = self.submission.result
if result is True:
score = 1.0
else:
if testruns:
score = (float(len([t for t in testruns if t.result])) /
float(len(testruns)))
else:
score = 0.0
send = self._send_result(score, str(result))
log.info(send)
return dict(assignment=self.assignment,
submission=self.submission,
user=self.user,
compilation=compilation,
testruns=testruns,
result=result,
score=score)
def index(self, *args, **kwargs):
try:
server = oauth2.Server()
server.add_signature_method(oauth2.SignatureMethod_HMAC_SHA1())
req = oauth2.Request.from_request(
request.method, request.url, request.headers, request.params, request.query_string
)
params = server.verify_request(req, oauth2.Consumer(self.key, self.secret), None)
except:
log.debug("LTI Tool Provider OAuth Error", exc_info=True)
flash("LTI Tool Provider OAuth Error", "error")
abort(403)
else:
log.debug(params)
user_name = (
params.get("tool_consumer_info_product_family_code", "external")
+ "_"
+ params.get("tool_consumer_instance_guid", "external")
+ "_"
+ params.get("user_id")
)
user = User.query.filter_by(user_name=user_name).first()
if not user:
log.info("New user %s", user_name)
user = User(
user_name=user_name,
display_name=params.get("lis_person_name_full"),
email_address=params.get("lis_person_contact_email_primary"),
)
DBSession.add(user)
submission = Submission.query.filter(Submission.assignment == self.assignment, Submission.user == user).first()
if not submission:
submission = Submission(
assignment=self.assignment,
filename=self.assignment.submission_filename or None,
source=self.assignment.submission_template or None,
language=self.assignment.allowed_languages[0],
user=user,
created=datetime.now(),
modified=datetime.now(),
)
DBSession.add(submission)
DBSession.flush()
session["lti"] = True
session["params"] = params
session["user"] = user.id
session["submission"] = submission.id
session.save()
redirect("/lti/%d/edit" % self.assignment.id)
def _default(self, language_id, *args, **kwargs):
try:
language_id = int(language_id)
language = DBSession.query(Language).filter_by(id=language_id).one()
except ValueError:
flash('Invalid Language id: %s' % language_id, 'error')
abort(400)
except NoResultFound:
flash('Language %d not found' % language_id, 'error')
abort(404)
except MultipleResultsFound: # pragma: no cover
log.error('Database inconsistency: Language %d', language_id, exc_info=True)
flash('An error occurred while accessing Language %d' % language_id, 'error')
abort(500)
return dict(page='language', language=language, languages=None)
def edit_(self, *args, **kwargs):
self._get_session_data()
v = SubmissionForm.validate(kwargs)
language = v["language"]
source = v["source"]
filename = v["filename"]
self.submission.assignment = self.assignment
self.submission.user = self.user
if self.submission.language != language:
self.submission.language = language
if self.submission.source != source:
self.submission.source = source
if self.submission.filename != filename:
self.submission.filename = filename
if self.submission in DBSession.dirty:
self.submission.modified = datetime.now()
DBSession.add(self.submission)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn("Submission %r could not be saved", self.submission, exc_info=True)
flash("Your submission could not be saved!", "error")
redirect("./edit")
else:
# redirect(self.submission.url + '/result')
pass
(compilation, testruns, result) = self.submission.run_tests()
testruns = sorted(set(self.submission.testruns), key=lambda s: s.date)
result = self.submission.result
if result is True:
score = 1.0
else:
if testruns:
score = float(len([t for t in testruns if t.result])) / float(len(testruns))
else:
score = 0.0
send = self._send_result(score, str(result))
log.info(send)
return dict(
assignment=self.assignment,
submission=self.submission,
user=self.user,
compilation=compilation,
testruns=testruns,
result=result,
score=score,
)
def setUp(self):
"""Prepare model test fixture."""
try:
new_attrs = {}
new_attrs.update(self.attrs)
new_attrs.update(self.do_get_dependencies())
self.obj = self.klass(**new_attrs)
DBSession.add(self.obj)
DBSession.flush()
return self.obj
except:
DBSession.rollback()
raise
def setUp(self):
"""Prepare model test fixture."""
try:
new_attrs = {}
new_attrs.update(self.attrs)
new_attrs.update(self.do_get_dependencies())
self.obj = self.klass(**new_attrs)
DBSession.add(self.obj)
DBSession.flush()
return self.obj
except:
DBSession.rollback()
raise
def test_enroll_team_new(self):
"""Enrolling for New Team"""
demo = self.configure_event('demo', 'team_new', None)
response = self.app.get('/events/demo/enroll', extra_environ=self.extra_environ)
response.mustcontain('Lesson A/B', 'Lesson C/D', 'Lesson E')
response.form.set('lesson', 1)
response = response.form.submit(extra_environ=self.extra_environ)
response.mustcontain('Lesson A/B', 'New Team', 'Team A', 'Team B')
response.form.set('team', '__new__')
response = response.form.submit(extra_environ=self.extra_environ)
user = DBSession.merge(self.user)
team = Team.query.filter(Team.name.like('New Team %%')).one()
assert user in team.members
assert team in user.teams
def _default(self, language_id, *args, **kw):
try:
language_id = int(language_id)
language = DBSession.query(Language).filter_by(
id=language_id).one()
except ValueError:
flash('Invalid Language id: %s' % language_id, 'error')
abort(400)
except NoResultFound:
flash('Language %d not found' % language_id, 'error')
abort(404)
except MultipleResultsFound:
log.error('Database inconsistency: Language %d' % language_id,
exc_info=True)
flash(
'An error occurred while accessing Language %d' % language_id,
'error')
abort(500)
return dict(page='language', language=language, languages=None)
def test_enroll_team_new(self):
"""Enrolling for New Team"""
demo = self.configure_event('demo', 'team_new', None)
response = self.app.get('/events/demo/enroll',
extra_environ=self.extra_environ)
response.mustcontain('Lesson A/B', 'Lesson C/D', 'Lesson E')
response.form.set('lesson', 1)
response = response.form.submit(extra_environ=self.extra_environ)
response.mustcontain('Lesson A/B', 'New Team', 'Team A', 'Team B')
response.form.set('team', '__new__')
response = response.form.submit(extra_environ=self.extra_environ)
user = DBSession.merge(self.user)
team = Team.query.filter(Team.name.like('New Team %%')).one()
assert user in team.members
assert team in user.teams
def clone(self):
s = Submission(
user=request.user,
assignment=self.submission.assignment,
filename=self.submission.filename,
source=self.submission.source,
language=self.submission.language,
)
DBSession.add(s)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
flash('Error cloning submission', 'error')
redirect(url(self.submission.url + '/show'))
finally:
s = DBSession.merge(s)
flash('Cloned submission %d from %d' % (s.id, self.submission.id), 'ok')
redirect(url(s.url + '/show'))
def clone(self, *args, **kwargs):
s = Submission(
user=request.user,
assignment=self.submission.assignment,
filename=self.submission.filename,
source=self.submission.source,
language=self.submission.language,
# TODO: Clone comment or not?
)
DBSession.add(s)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
flash('Error cloning submission', 'error')
redirect(url(self.submission.url + '/show'))
finally:
s = DBSession.merge(s)
flash('Cloned submission %d from %d' % (s.id, self.submission.id), 'ok')
redirect(url(s.url + '/show'))
def submit(self):
'''Create new submission for this assignment'''
if not self.assignment.is_active and \
not request.allowance(self.assignment):
flash('This assignment is not active, you may not create a submission', 'warning')
redirect(url(self.assignment.url))
submission = Submission(assignment=self.assignment, user=request.user,
created=datetime.now())
DBSession.add(submission)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Error creating new submission', exc_info=True)
flash('Error creating new submission', 'error')
redirect(url(self.assignment.url))
else:
redirect(url(submission.url + '/edit'))
def submit(self):
'''Create new submission for this assignment'''
if not self.assignment.is_active and \
not request.allowance(self.assignment):
flash(
'This assignment is not active, you may not create a submission',
'warning')
redirect(url(self.assignment.url))
submission = Submission(assignment=self.assignment,
user=request.user,
created=datetime.now())
DBSession.add(submission)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Error creating new submission', exc_info=True)
flash('Error creating new submission', 'error')
redirect(url(self.assignment.url))
else:
redirect(url(submission.url + '/edit'))
def delete(self):
subm_id = self.submission.id
subm_url = self.submission.url
try:
if (getattr(request, 'user', None) == self.submission.user or
request.allowance(self.submission)):
DBSession.delete(self.submission)
DBSession.flush()
else:
#abort(403)
flash('You have no permission to delete this Submission', 'warning')
redirect(url(self.submission.url + '/show'))
except SQLAlchemyError:
DBSession.rollback()
log.warn('Submission %d could not be deleted', self.submission.id, exc_info=True)
flash('Submission could not be deleted', 'error')
redirect(url(self.submission.url + '/show'))
else:
flash('Submission %d deleted' % (subm_id), 'ok')
if request.referer and not subm_url in request.referer:
# Most likely coming from the submission overview page
redirect(request.referer)
else:
redirect(url(self.assignment.url))
def edit_(self, language=None, source=None, filename=None, comment=None, *args, **kwargs):
self._edit_permissions()
log.debug(dict(submission_id=self.submission.id,
assignment_id=self.assignment.id,
language=language, filename=filename, source=source))
#self.submission.assignment = self.assignment
#if request.student:
# self.submission.student = request.student
if self.submission.language != language:
self.submission.language = language
if self.submission.source != source:
self.submission.source = source
if self.submission.filename != filename:
self.submission.filename = filename
# TODO: Only changing the comment should not trigger re-testing, but it does.
if self.submission.comment != comment:
self.submission.comment = comment
if self.submission in DBSession.dirty:
self.submission.modified = datetime.now()
if self.submission in DBSession.dirty:
DBSession.add(self.submission)
try:
DBSession.flush()
except SQLAlchemyError:
DBSession.rollback()
log.warn('Submission %r could not be saved', self.submission, exc_info=True)
flash('Your submission could not be saved!', 'error')
redirect(self.submission.url + '/edit')
else:
redirect(self.submission.url + '/result')
def delete(self, *args, **kwargs):
subm_id = self.submission.id
subm_url = self.submission.url
try:
if (getattr(request, 'user', None) == self.submission.user or
request.allowance(self.submission)):
DBSession.delete(self.submission)
DBSession.flush()
else:
#abort(403)
flash('You have no permission to delete this Submission', 'warning')
redirect(url(self.submission.url + '/show'))
except SQLAlchemyError:
DBSession.rollback()
log.warn('Submission %r could not be deleted', self.submission, exc_info=True)
flash('Submission could not be deleted', 'error')
redirect(url(self.submission.url + '/show'))
else:
flash('Submission %d deleted' % (subm_id), 'ok')
if request.referer and not subm_url in request.referer:
# Most likely coming from the submission overview page
redirect(request.referer)
else:
redirect(url(self.assignment.url))
def enroll(self, password=None, lesson=None, team=None, *args, **kwargs):
'''Event enrolling page'''
params = {}
if not self.event.enroll:
flash('Enroll not allowed', 'error')
return HTTPForbidden()
if self.event.password and password != self.event.password:
if password:
flash('Wrong password', 'error')
c.text = u'Please enter the password to enroll for this event:'
c.form = PasswordEnrollForm
else:
if password:
params['password'] = password
if self.event.enroll == 'event':
try:
self.event._members.append(request.user)
DBSession.flush()
except SQLAlchemyError:
log.warn('Error while enrolling user %r for event %r:', request.user, self.event, exc_info=True)
flash('An error occured', 'error')
else:
flash('Enrolled for Event "%s"' % self.event.name,
'ok')
redirect(self.event.url)
if self.event.enroll in ('lesson_team', 'team', 'team_new') and team:
if self.event.enroll == 'team_new' and team == '__new__':
try:
lesson = Lesson.query.get(int(lesson))
except ValueError:
lesson = team = None
else:
# Get unique team name
q = Team.query.filter_by(lesson=lesson)
i = q.count() + 1
while True:
name = 'New Team %d' % i
t = q.filter_by(name=name).first()
if not t:
break
i = i + 1
team = Team(lesson=lesson, name=name)
DBSession.add(team)
else:
try:
team = Team.query.get(int(team))
except ValueError:
team = None
if team:
try:
team.members.append(request.user)
DBSession.flush()
except SQLAlchemyError:
log.warn('Error while enrolling user %r for team %r:', request.user, team, exc_info=True)
flash('An error occured', 'error')
lesson = lesson.id
else:
flash('Enrolled for Team "%s" in Lesson "%s" in Event "%s"'
% (team.name, team.lesson.name, self.event.name),
'ok')
redirect(self.event.url)
else:
flash('Selected Team does not exist', 'error')
if self.event.enroll in ('lesson', 'lesson_team', 'team', 'team_new') and not lesson:
c.text = u'Please select the lesson you would like to attend:'
c.form = LessonSelectionForm(event=self.event, action=url('', params))
if self.event.enroll == 'lesson' and lesson:
try:
lesson = Lesson.query.get(int(lesson))
except ValueError:
lesson = None
if lesson:
try:
lesson._members.append(request.user)
DBSession.flush()
except SQLAlchemyError:
log.warn('Error while enrolling user %r for lesson %r:', request.user, lesson, exc_info=True)
flash('An error occured', 'error')
else:
flash('Enrolled for Lesson "%s" in Event "%s"'
% (lesson.name, self.event.name),
'ok')
redirect(self.event.url)
else:
flash('Selected Lesson does not exist',
'error')
if self.event.enroll in ('lesson_team', 'team', 'team_new') and lesson:
try:
lesson = Lesson.query.get(int(lesson))
except ValueError:
lesson = None
else:
params['lesson'] = lesson.id
c.text = u'Please select the team in which you would like to work:'
c.form = TeamSelectionForm(
lesson=lesson,
new=bool(self.event.enroll == 'team_new'),
action=url('', params),
)
return dict(page='events', heading=u'Enroll for %s' % self.event.name)
args = parse_args()
load_config(args.conf_file)
#print model.DBSession.query(model.User.user_name).all()
events = Session.query(model.Event).all()
print [(i, e.name) for i,e in enumerate(events)]
event_id = raw_input('event_id: ')
event = events[int(event_id)]
fix_languages = raw_input("Allow all languages on all assignments? [y]")
if fix_languages == 'y':
l = Session.query(model.Language).all()
for a in Session.query(model.Assignment).filter_by(event_id=event.id).all():
a = Session.merge(a)
a.allowed_languages=l
Session.add(a)
try:
transaction.commit()
except IntegrityError:
print traceback.format_exc()
transaction.abort()
fix_visible_tests = raw_input("Fix boolean visible attribute on tests? [y]")
if fix_visible_tests == 'y':
def by_user_name(cls, username):
"""Return the user object whose user name is ``username``."""
return DBSession.query(cls).filter_by(user_name=username).first()
def by_email_address(cls, email):
"""Return the user object whose email address is ``email``."""
return DBSession.query(cls).filter_by(email_address=email).first()
def by_email_address(cls, email):
"""Return the user object whose email address is ``email``."""
return DBSession.query(cls).filter_by(email_address=email).first()
def _default(self, *args, **kw):
#TODO: This filtering really needs to be rewritten!
filters = dict(zip(args[::2], args[1::2]))
real_filters = dict(assignment_id=set(), user_id=set())
if self.assignment:
real_filters['assignment_id'] = self.assignment.id
else:
sheet = None
if self.sheet:
sheet = self.sheet
elif 'sheet' in filters:
try:
s = int(filters['sheet'])
sheet = DBSession.query(Sheet).filter_by(event_id=self.event.id)\
.filter_by(sheet_id=s).one()
except NoResultFound:
pass
if sheet:
if 'assignment' in filters:
try:
a = int(filters['assignment'])
a_id = DBSession.query(Assignment.id).filter_by(sheet_id=sheet.id)\
.filter_by(assignment_id=a).one().id
real_filters['assignment_id'] |= set((a_id, ))
except NoResultFound:
pass
else:
real_filters['assignment_id'] |= set((a.id for a in sheet.assignments))
if self.event:
# Dirty, dirty hack to properly filter assignments by event
if real_filters['assignment_id']:
# Only allow filters by assignments from the set event
real_filters['assignment_id'] &= set((a.id for s in self.event.sheets for a in s.assignments))
else:
# Simply filter by assignments for this event
real_filters['assignment_id'] = set((a.id for s in self.event.sheets for a in s.assignments))
if 'lesson' in filters:
try:
l = int(filters['lesson'])
q1 = DBSession.query(User.id).join(lesson_members).filter_by(lesson_id=l)
q2 = DBSession.query(User.id).join(team_members).join(Team).filter_by(lesson_id=l)
students = q1.union(q2)
real_filters['user_id'] |= set((s.id for s in students))
except SQLAlchemyError:
pass
if 'team' in filters:
try:
students = DBSession.query(User.id).join(team_members)\
.filter_by(team_id=int(filters['team'])).join(Team)
if self.lesson:
students = students.filter_by(lesson_id=self.lesson.id)
else:
#students = students.filter(Team.lesson_id.in_(l.id for l in self.event.lessons))
students = students.join(Team.lesson).filter_by(event_id=self.event.id)
real_filters['user_id'] |= set((s.id for s in students))
except SQLAlchemyError:
pass
if 'user' in filters:
try:
user_id = DBSession.query(User.id).filter_by(id=int(filters['user'])).one().id
real_filters['user_id'] |= set((user_id, ))
except NoResultFound:
pass
# Cleanup filters for performancy
definite_filters = dict()
for (k, v) in real_filters.iteritems():
if v:
if isinstance(v, (list, tuple, set)) and len(v) == 1:
definite_filters[k] = v.pop()
else:
definite_filters[k] = v
c.table = self.table
values = self.table_filler.get_value(filters=definite_filters)
return dict(page='event', view=None, values=values)
def index(self):
languages = DBSession.query(Language)
return dict(page='language', language=None, languages=languages)
def setup():
"""Function called by nose on module load"""
setup_db()
DBSession.add(
User(id=4771, user_name='dummy', email_address='*****@*****.**'))
DBSession.flush()
def tearDown(self):
"""Finish model test fixture."""
DBSession.rollback()
def test_query_obj(self):
"""Model objects can be queried"""
obj = DBSession.query(self.klass).one()
for key, value in self.attrs.iteritems():
assert_equals(getattr(obj, key), value)
def index(self, *args, **kwargs):
languages = DBSession.query(Language)
return dict(page='language', language=None, languages=languages)
def setup():
"""Function called by nose on module load"""
setup_db()
DBSession.add(User(id=4771, user_name='dummy', email_address='*****@*****.**'))
DBSession.flush()
def configure_event(self, url, enroll, password):
event = Event.query.filter_by(_url=url).one()
event.enroll = enroll
event.password = password
transaction.commit()
return DBSession.merge(event)
def by_user_name(cls, username):
"""Return the user object whose user name is ``username``."""
return DBSession.query(cls).filter_by(user_name=username).first()
