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)})