def send_confirmation_email(self,
user,
program,
repeat=False,
override=False):
options = program.getModuleExtension('StudentClassRegModuleInfo')
## Get or create a userbit indicating whether or not email's been sent.
try:
confbit, created = UserBit.objects.get_or_create(
user=user,
verb=GetNode("V/Flags/Public"),
qsc=GetNode("/".join(program.anchor.tree_encode()) +
"/ConfEmail"))
except Exception:
created = False
if (created or repeat) and (options.send_confirmation or override):
try:
receipt_template = Template(
DBReceipt.objects.get(program=program,
action='confirmemail').receipt)
except:
receipt_template = select_template([
'program/confemails/%s_confemail.txt' % (program.id),
'program/confirm_email.txt'
])
send_mail("Thank you for registering for %s!" %(program.niceName()), \
receipt_template.render(Context({'user': user, 'program': program}, autoescape=False)), \
("%s <%s>" %(program.niceName() + " Directors", program.director_email)), \
[user.email], True)
def home(request):
# Get navbars corresponding to the 'home' category
nav_category, created = NavBarCategory.objects.get_or_create(name='home')
context = {
'navbar_list': makeNavBar(None, GetNode('Q/Web'), '', nav_category)
}
return render_to_response('index.html', request, GetNode('Q/Web'), context)
def qscs(self):
if not hasattr(self, '_qscs'):
self._qscs = {
'interview': GetNode( self.program_anchor_cached().get_uri() + '/TeacherEvents/Interview' ),
'training': GetNode( self.program_anchor_cached().get_uri() + '/TeacherEvents/Training' )
}
return self._qscs
def testMorph(self):
class scratchCls(object):
pass
class scratchDict(dict):
def cycle_key(self):
pass
def flush(self):
for i in self.keys():
del self[i]
# Make up a fake request object
# This definitely doesn't meet the spec of the real request object;
# if tests fail as a result in the future, it'll need to be fixed.
request = scratchCls()
request.backend = 'django.contrib.auth.backends.ModelBackend'
request.user = None
request.session = scratchDict()
# Create a couple users and a userbit
self.user, created = ESPUser.objects.get_or_create(
username='******')
self.userbit = UserBit.objects.get_or_create(
user=self.user, verb=GetNode('V/Administer'), qsc=GetNode('Q'))
self.basic_user, created = ESPUser.objects.get_or_create(
username='******')
self.userbit = UserBit.objects.get_or_create(
user=self.basic_user,
verb=GetNode('V/Flags/UserRole/Student'),
qsc=GetNode('Q'))
self.user.backend = request.backend
self.basic_user.backend = request.backend
login(request, self.user)
self.assertEqual(request.user, self.user,
"Failed to log in as '%s'" % self.user)
request.user.switch_to_user(request, self.basic_user, None, None)
self.assertEqual(request.user, self.basic_user,
"Failed to morph into '%s'" % self.basic_user)
request.user.switch_back(request)
self.assertEqual(request.user, self.user,
"Failed to morph back into '%s'" % self.user)
blocked_illegal_morph = True
try:
ESPUser(request.user).switch_to_user(request, self.basic_user,
None, None)
self.assertEqual(request.user, self.basic_user,
"Failed to morph into '%s'" % self.basic_user)
except ESPError():
blocked_illegal_morph = True
self.assertTrue(blocked_illegal_morph,
"User '%s' was allowed to morph into an admin!")
def setUp(self):
self.user, created = ESPUser.objects.get_or_create(
username='******')
self.user.is_staff = False
self.user.is_superview = False
UserBit.objects.filter(user=self.user,
qsc=GetNode('Q'),
verb=GetNode('V/Administer')).delete()
UserBit.objects.filter(
user=self.user,
qsc=GetNode('Q'),
verb=GetNode('V/Flags/UserRole/Administrator')).delete()
def runTest(self):
# Make sure user starts off with no administrator priviliges
self.assertFalse(self.user.is_staff)
self.assertFalse(self.user.is_superuser)
self.assertFalse(
UserBit.objects.UserHasPerms(user=self.user,
qsc=GetNode('Q'),
verb=GetNode('V/Administer')))
self.assertFalse(
UserBit.objects.UserHasPerms(
user=self.user,
qsc=GetNode('Q'),
verb=GetNode('V/Flags/UserRole/Administrator')))
# Now make admin_test into an admin using make_admin
make_user_admin(self.user)
# Make sure user now has administrator privileges
self.assertTrue(self.user.is_staff)
self.assertTrue(self.user.is_superuser)
self.assertTrue(
UserBit.objects.UserHasPerms(user=self.user,
qsc=GetNode('Q'),
verb=GetNode('V/Administer')))
self.assertTrue(
UserBit.objects.UserHasPerms(
user=self.user,
qsc=GetNode('Q'),
verb=GetNode('V/Flags/UserRole/Administrator')))
# Make sure that an unprivileged access to /myesp/makeadmin/ returns 403 Forbidden
response = self.client.get('/myesp/makeadmin/')
self.assertEqual(response.status_code, 403)
def setUp(self):
SeleniumTestCase.setUp(self)
# Make Q/Web public
UserBit.objects.create(verb=GetNode('V/Flags/Public'),
qsc=GetNode('Q/Web'))
# Make our users
self.admin_user, created = ESPUser.objects.get_or_create(
username='******', first_name='Harry', last_name='Alborez')
self.admin_user.set_password(self.PASSWORD_STRING)
make_user_admin(self.admin_user)
self.qsd_user, created = ESPUser.objects.get_or_create(
username='******', first_name='Aylik', last_name='Kewesd')
self.qsd_user.set_password(self.PASSWORD_STRING)
self.qsd_user.userbit_set.add(
UserBit(verb=GetNode('V/Administer/Edit'),
qsc=GetNode('Q'),
recursive=True))
self.qsd_user.save()
# Check that a NavBarCategory exists
if len(NavBarCategory.objects.all()) < 1:
nbc = NavBarCategory()
nbc.name = 'default'
nbc.save()
# Make our test page
qsd_rec_new = QuasiStaticData()
qsd_rec_new.path = GetNode('Q/Web')
qsd_rec_new.name = 'test'
qsd_rec_new.author = self.admin_user
qsd_rec_new.nav_category = NavBarCategory.default()
qsd_rec_new.content = ''
qsd_rec_new.title = 'Test page'
qsd_rec_new.description = ''
qsd_rec_new.keywords = ''
qsd_rec_new.save()
# Set the port that the webdriver will try to access
self.driver.testserver_port = settings.VARNISH_PORT
# Add the varnish_purge tag
Tag.objects.get_or_create(key='varnish_purge', value='true')
# Set up the correct site
site = Site.objects.get_current()
site.domain = settings.VARNISH_HOST + ":" + str(settings.VARNISH_PORT)
site.save()
def testDelete(self):
from esp.datatree.models import GetNode
from esp.users.models import UserBit
# Create a user and a userbit
self.user, created = ESPUser.objects.get_or_create(
username='******')
self.userbit = UserBit.objects.get_or_create(
user=self.user, verb=GetNode('V/Administer'), qsc=GetNode('Q'))
# Save the ID and then delete the user
uid = self.user.id
self.user.delete()
# Make sure it's gone.
self.failUnless(User.objects.filter(id=uid).count() == 0)
self.failUnless(ESPUser.objects.filter(id=uid).count() == 0)
self.failUnless(UserBit.objects.filter(user=uid).count() == 0)
def myesp(request, module):
""" Return page handled by myESP (generally, a user-specific page) """
if myesp_handlers.has_key(module):
return myesp_handlers[module](request, module)
return render_to_response('users/construction', request,
GetNode('Q/Web/myesp'), {})
def testInlineCorrectness(self):
self.client.logout()
# Create an inline QSD
qsd_rec_new = QuasiStaticData()
qsd_rec_new.path = GetNode('Q/Programs')
qsd_rec_new.name = "learn:bar"
qsd_rec_new.author = self.author
qsd_rec_new.nav_category = NavBarCategory.default()
qsd_rec_new.content = "Inline Testing 123"
qsd_rec_new.title = "Test QSD page"
qsd_rec_new.description = ""
qsd_rec_new.keywords = ""
qsd_rec_new.save()
# Render a template that uses the inline_qsd template tag
template_data = """
{% load render_qsd %}
{% render_inline_qsd "Q/Programs" "learn:bar" %}
"""
template = Template(template_data)
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 123" in response_content)
# Update the template and check again
qsd_rec_new.content = "Inline Testing 456"
qsd_rec_new.save()
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 456" in response_content)
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 456" in response_content)
def save_timeslot(self, program, slot, type, anchor):
slot.start = self.cleaned_data['start']
slot.end = slot.start + timedelta(hours=self.cleaned_data['hours'], minutes=self.cleaned_data['minutes'])
if type == "training":
slot.event_type = EventType.objects.get_or_create(description='Teacher Training')[0]
elif type == "interview":
slot.event_type = EventType.objects.get_or_create(description='Teacher Interview')[0]
else:
slot.event_type = EventType.objects.all()[0] # default event type
# find the next integer that we should use to name this node
children_names = []
for child in anchor.children():
children_names.append(child.name)
counter = 0
while str(counter) in children_names:
counter += 1
slot.anchor = GetNode(anchor.uri + "/" + str(counter))
slot.short_description = slot.start.strftime('%A, %B %d %Y %I:%M %p') + " to " + slot.end.strftime('%I:%M %p')
slot.description = slot.short_description
slot.save()
def testGradeChange(self):
# Create the admin user
adminUser, c1 = ESPUser.objects.get_or_create(username='******')
adminUser.set_password('password')
make_user_admin(adminUser)
# Create the student user
studentUser, c2 = ESPUser.objects.get_or_create(username='******')
# Make it a student
role_bit, created = UserBit.objects.get_or_create(user=studentUser, qsc=GetNode('Q'), verb=GetNode('V/Flags/UserRole/Student'), recursive=False)
# Give it a starting grade
student_studentinfo = StudentInfo(user=studentUser, graduation_year=ESPUser.YOGFromGrade(9))
student_studentinfo.save()
student_regprofile = RegistrationProfile(user=studentUser, student_info=student_studentinfo, most_recent_profile=True)
student_regprofile.save()
# Check that the grade starts at 9
self.failUnless(studentUser.getGrade() == 9)
# Login the admin
self.failUnless(self.client.login(username="******", password="******"))
testGrade = 11
curYear = ESPUser.current_schoolyear()
gradYear = curYear + (12 - testGrade)
self.client.get("/manage/userview?username=student&graduation_year="+str(gradYear))
self.failUnless(studentUser.getGrade() == testGrade, "Grades don't match: %s %s" % (studentUser.getGrade(), testGrade))
# Clean up
if (c1):
adminUser.delete()
if (c2):
studentUser.delete()
def forwards(self, orm):
# Removing unique constraint on 'Entry', fields ['slug', 'anchor']
# [This doesn't seem to be in all of our production databases. -Michael]
# db.delete_unique('miniblog_entry', ['slug', 'anchor_id'])
# Delete all announcements/entries that were not anchored on Q/Web
# since those anchor points now have no meaning
try:
web_node_id = GetNode('Q/Web').id
except DataTree.DoesNotExist:
# If there is no DataTree, delete everything.
web_node_id = -1
db.execute(
'DELETE FROM "miniblog_announcementlink" WHERE "anchor_id" != %s',
[
web_node_id,
])
db.execute('DELETE FROM "miniblog_entry" WHERE "anchor_id" != %s', [
web_node_id,
])
# Deleting field 'AnnouncementLink.anchor'
db.delete_column('miniblog_announcementlink', 'anchor_id')
# Deleting field 'Entry.anchor'
db.delete_column('miniblog_entry', 'anchor_id')
def testPageCorrectness(self):
self.client.logout()
# Check that QSD with desired URL does not exist
response = self.client.get(self.url)
self.assertEqual(response.status_code, 404)
# Create QSD with desired URL
qsd_rec_new = QuasiStaticData()
qsd_rec_new.path = GetNode('Q/Programs')
qsd_rec_new.name = "learn:foo"
qsd_rec_new.author = self.author
qsd_rec_new.nav_category = NavBarCategory.default()
qsd_rec_new.content = "Testing 123"
qsd_rec_new.title = "Test QSD page"
qsd_rec_new.description = ""
qsd_rec_new.keywords = ""
qsd_rec_new.save()
# Check that page now exists and has proper content
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTrue('Testing 123' in response.content)
# Edit QSD and check that page content has updated
qsd_rec_new.content = "Testing 456"
qsd_rec_new.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTrue('Testing 456' in response.content)
def setUp(self):
# Determine URL for QSD page to be tested
section = 'learn'
pagename = 'foo'
self.url = '/%s/%s.html' % (section, pagename)
# Create user to function as QSD author
new_admin, created = ESPUser.objects.get_or_create(
username='******')
new_admin.set_password('password')
new_admin.save()
role_bit, created = UserBit.objects.get_or_create(
user=new_admin,
verb=GetNode('V/Flags/UserRole/Administrator'),
qsc=GetNode('Q'),
recursive=False)
self.author = new_admin
def varnish_purge(request):
# Authenticate
if (not request.user or not request.user.is_authenticated()
or not ESPUser(request.user).isAdministrator()) and (
not UserBit.objects.user_has_verb(
request.user, GetNode('V/Administer/Edit/QSD'))):
raise PermissionDenied
# Purge the page specified
purge_page(request.POST['page'])
# Return the minimum possible
return HttpResponse('')
def volunteer_signup(request):
volunteer_anchor = GetNode('Q/Web/getinvolved')
if request.POST:
response = VolunteerRegistrationForm(request.POST)
if response.is_valid():
data = response.save(from_addr='Splash! Chicago <*****@*****.**>', destination_addrs=['Race Wright <*****@*****.**>'])
return render_to_response("shortterm/volunteer_signup/complete.html", request, context={'anchor': volunteer_anchor})
else:
response = VolunteerRegistrationForm()
return render_to_response("shortterm/volunteer_signup/form.html", request, context={'form': response, 'anchor': volunteer_anchor})
def __init__(self, program_or_anchor, *args, **kwargs):
super(TeacherQuizController, self).__init__(*args, **kwargs)
self.program_anchor = program_or_anchor
# We'll also accept a program
if hasattr(self.program_anchor, 'anchor'):
self.program_anchor = self.program_anchor.anchor
# Make a sad attempt at type safety
if not isinstance(self.program_anchor, DataTree):
raise TypeError(
"Argument to constructor should be Program or DataTree node.")
# Some setup
self.reg_verb = GetNode('V/Flags/Registration/Teacher/QuizDone')
def test_deadline_met(self):
self.failUnless(self.moduleobj.deadline_met())
self.moduleobj.user = self.students[0]
self.failUnless(self.moduleobj.deadline_met())
ubs = UserBit.objects.filter(
verb=GetNode('V/Deadline/Registration/Teacher'),
qsc=self.program.anchor_id)
for ub in ubs:
ub.expire()
self.failUnless(not self.moduleobj.deadline_met())
self.moduleobj.user = self.teacher
self.failUnless(not self.moduleobj.deadline_met())
transaction.rollback()
def teachers(self, QObject=False):
""" Returns a list of teachers who have submitted the acknowledgement. """
from datetime import datetime
qf = Q(userbit__qsc=self.program_anchor_cached(),
userbit__verb=GetNode(
'V/Flags/Registration/Teacher/Acknowledgement'),
userbit__startdate__lte=datetime.now(),
userbit__enddate__gte=datetime.now())
if QObject is True:
return {'acknowledgement': self.getQForUser(qf)}
teacher_list = ESPUser.objects.filter(qf).distinct()
return {
'acknowledgement': teacher_list
} #[t['user'] for t in teacher_list]}
def _checkDeadline_helper(method, extension, moduleObj, request, tl, *args, **kwargs):
from esp.users.models import UserBit
from esp.datatree.models import DataTree, GetNode, QTree, get_lowest_parent, StringToPerm, PermToString
if tl != 'learn' and tl != 'teach':
return (True, None)
response = None
canView = False
if not_logged_in(request):
response = HttpResponseRedirect('%s?%s=%s' % (LOGIN_URL, REDIRECT_FIELD_NAME, quote(request.get_full_path())))
else:
canView = request.user.updateOnsite(request)
if not canView:
canView = UserBit.UserHasPerms(request.user,
request.program.anchor_id,
GetNode('V/Deadline/Registration/'+{'learn':'Student',
'teach':'Teacher'}[tl]+extension))
return (canView, response)
def backwards(self, orm):
# Adding field 'AnnouncementLink.anchor'
db.add_column('miniblog_announcementlink',
'anchor',
self.gf('django.db.models.fields.related.ForeignKey')(
default=1, to=orm['datatree.DataTree']),
keep_default=False)
# Adding field 'Entry.anchor'
db.add_column('miniblog_entry',
'anchor',
self.gf('django.db.models.fields.related.ForeignKey')(
default=1, to=orm['datatree.DataTree']),
keep_default=False)
# Set AnnouncementLink and Entry anchors to Q/Web
web_node = GetNode('Q/Web')
orm['miniblog.AnnouncementLink'].objects.all().update(anchor=web_node)
orm['miniblog.Entry'].objects.all().update(anchor=web_node)
def archives(request, selection, category=None, options=None):
""" Return a page with class archives """
sortparams = []
if request.POST and request.POST.has_key('newparam'):
if request.POST['newparam']:
sortparams.append(request.POST['newparam'])
for key in request.POST:
if key.startswith('sortparam') and request.POST[
key] != request.POST['newparam']:
sortparams.append(request.POST[key])
# The selection variable is the type of data they want to see:
# classes, programs, teachers, etc.
if archive_handlers.has_key(selection):
return archive_handlers[selection](request, category, options,
sortparams)
return render_to_response('users/construction', request, GetNode('Q/Web'),
{})
def _checkStudent(moduleObj, request, *args, **kwargs):
if not_logged_in(request):
return HttpResponseRedirect('%s?%s=%s' %
(LOGIN_URL, REDIRECT_FIELD_NAME,
quote(request.get_full_path())))
if not request.user.isStudent() and not request.user.isAdmin(
moduleObj.program):
allowed_student_types = Tag.getTag("allowed_student_types",
moduleObj.program,
default='')
matching_user_types = UserBit.valid_objects().filter(
user=request.user,
verb__parent=GetNode("V/Flags/UserRole"),
verb__name__in=allowed_student_types.split(","))
if not matching_user_types:
return render_to_response('errors/program/notastudent.html',
request,
(moduleObj.program, 'learn'), {})
return method(moduleObj, request, *args, **kwargs)
def _checkGrade(moduleObj, request, tl, *args, **kwargs):
errorpage = 'errors/program/wronggrade.html'
from esp.datatree.models import DataTree, GetNode, QTree, get_lowest_parent, StringToPerm, PermToString
from esp.users.models import UserBit
verb_override = GetNode('V/Flags/Registration/GradeOverride')
# if there's grade override we can just skip everything
if UserBit.UserHasPerms(user = request.user,
qsc = moduleObj.program.anchor_id,
verb = verb_override):
return method(moduleObj, request, tl, *args, **kwargs)
# now we have to use the grade..
# get the last grade...
cur_grade = request.user.getGrade(moduleObj.program)
if cur_grade != 0 and (cur_grade < moduleObj.program.grade_min or \
cur_grade > moduleObj.program.grade_max):
return render_to_response(errorpage, request, (moduleObj.program, tl), {})
return method(moduleObj, request, tl, *args, **kwargs)
def forwards(self, orm):
# Save the original verb names
original_verb_len = len('V/Flags/Registration/')
## MIT-specific fix: Make sure all SCRMI's actually have regg verbs
try:
default_verb = GetNode("V/Flags/Registration/Enrolled")
except DataTree.DoesNotExist:
# Insufficient tree information; use null
default_verb = DataTree()
# Shorthand for StudentClassRegModuleInfo model from frozen ORM
scrmi_model = orm['modules.StudentClassRegModuleInfo']
verb_map = {}
name_map = {}
for item in scrmi_model.objects.all().values_list('id', 'signup_verb_id'):
verb_map[item[0]] = item[1] if item[1] else default_verb.id
for key, val in verb_map.iteritems():
name_map[key] = DataTree.objects.get(id=val).get_uri()[original_verb_len:]
# Delete the verbs (need to allow null values)
db.start_transaction()
db.alter_column('modules_studentclassregmoduleinfo', 'signup_verb_id', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['datatree.DataTree'], null=True))
for item in scrmi_model.objects.all():
item.signup_verb = None
item.save()
db.commit_transaction()
# Changing field 'StudentClassRegModuleInfo.signup_verb'
db.alter_column('modules_studentclassregmoduleinfo', 'signup_verb_id', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['program.RegistrationType'], null=True))
db.start_transaction()
# Change verb IDs to RegistrationTypes
for item in scrmi_model.objects.all():
item.signup_verb = RegistrationType.get_map(include=[name_map[item.id]], category='student')[name_map[item.id]]
item.save()
db.commit_transaction()
db.alter_column('modules_studentclassregmoduleinfo', 'signup_verb_id', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['program.RegistrationType']))
def deadline_met(self, extension=''):
from esp.users.models import UserBit
from esp.datatree.models import GetNode, DataTree
if not get_current_request().user or not self.program:
raise ESPError(False), "There is no user or program object!"
if self.module.module_type != 'learn' and self.module.module_type != 'teach':
return True
canView = get_current_request().user.isOnsite(self.program)
if not canView:
test_node = GetNode('V/Deadline/Registration/' + {
'learn': 'Student',
'teach': 'Teacher'
}[self.module.module_type] + extension)
canView = UserBit.UserHasPerms(get_current_request().user,
self.program.anchor_id, test_node)
return canView
def user_registration_validate(request):
"""Handle the account creation logic when the form is submitted
This function is overloaded to handle either one or two phase reg"""
if Tag.getTag("ask_about_duplicate_accounts", default="false") == "false":
form = SinglePhaseUserRegForm(request.POST)
else:
form = UserRegForm(request.POST)
if form.is_valid():
try:
#there is an email-only account with that email address to upgrade
user = ESPUser.objects.get(email=form.cleaned_data['email'],
password='******')
except User.DoesNotExist:
try:
#there is an inactive account with that username
user = ESPUser.objects.filter(
username=form.cleaned_data['username'],
is_active=False).latest('date_joined')
except User.DoesNotExist:
user = ESPUser(email=form.cleaned_data['email'])
user.username = form.cleaned_data['username']
user.last_name = form.cleaned_data['last_name']
user.first_name = form.cleaned_data['first_name']
user.set_password(form.cleaned_data['password'])
# Append key to password and disable until activation if desired
if Tag.getTag('require_email_validation',
default='false').lower() != 'false':
userkey = random.randint(0, 2**31 - 1)
user.password += "_%d" % userkey
user.is_active = False
user.save()
ESPUser_Profile.objects.get_or_create(user=user)
role_verb = GetNode('V/Flags/UserRole/%s' %
form.cleaned_data['initial_role'])
role_bit = UserBit.objects.create(user=user,
verb=role_verb,
qsc=request.get_node('Q'),
recursive=False)
if Tag.getTag('require_email_validation',
default='false').lower() == 'false':
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
login(request, user)
return HttpResponseRedirect('/myesp/profile/')
else:
send_activation_email(user, userkey)
return render_to_response(
'registration/account_created_activation_required.html',
request, request.get_node('Q/Web/myesp'), {
'user': user,
'site': Site.objects.get_current()
})
else:
return render_to_response('registration/newuser.html', request,
request.get_node('Q/Web/myesp'),
{'form': form})
def __init__(self, *args, **kwargs):
super(TeacherQuizModule, self).__init__(*args, **kwargs)
self.reg_verb = GetNode('V/Flags/Registration/Teacher/QuizDone')
def view_all(request):
return render_to_response(
'cache/view_all.html', request, GetNode('Q/Web'),
{'caches': sorted(all_caches.values(), key=lambda c: c.name)})
