rem
stringlengths 0
322k
| add
stringlengths 0
2.05M
| context
stringlengths 8
228k
|
|---|---|---|
return Popen([MM_PATH + "add_members", "--regular-members-file=-", list], stdin=PIPE).communicate(member)
|
return Popen([MM_PATH + "add_members", "--regular-members-file=-", list], stdin=PIPE, stdout=PIPE, stderr=PIPE).communicate(member)
|
def add_list_member(list, member): """ Add the e-mail address 'member' to the local Mailman mailing list 'list' "member" may be a list (or other iterable) of e-mail address strings, in which case all addresses will be added. """ if isinstance(member, User): member = member.email if hasattr(member, "filter"): member = [x.email for x in member] if not isinstance(member, basestring): member = "\n".join(member) return Popen([MM_PATH + "add_members", "--regular-members-file=-", list], stdin=PIPE).communicate(member)
|
return Popen([MM_PATH + "remove_members", "--file=-", list], stdin=PIPE).communicate(member)
|
return Popen([MM_PATH + "remove_members", "--file=-", list], stdin=PIPE, stdout=PIPE, stderr=PIPE).communicate(member)
|
def remove_list_member(list, member): """ Remove the e-mail address 'member' from the local Mailman mailing list 'list' "member" may be a list (or other iterable) of e-mail address strings, in which case all addresses will be removed. """ if isinstance(member, User): member = member.email if hasattr(member, "filter"): member = [x.email for x in member] if not isinstance(member, basestring): member = "\n".join(member) return Popen([MM_PATH + "remove_members", "--file=-", list], stdin=PIPE).communicate(member)
|
def list_contents(list):
|
def list_contents(lst):
|
def list_contents(list): """ Return the list of e-mail addresses on the specified mailing list """ return Popen([MM_PATH + "list_members", list]).communicate()[0].split('\n')
|
return Popen([MM_PATH + "list_members", list]).communicate()[0].split('\n')
|
return Popen([MM_PATH + "list_members", lst], stdout=PIPE, stderr=PIPE).communicate()[0].split('\n')
|
def list_contents(list): """ Return the list of e-mail addresses on the specified mailing list """ return Popen([MM_PATH + "list_members", list]).communicate()[0].split('\n')
|
@cache_control(public=True, max_age=10)
|
@vary_on_cookie @needs_student
|
def catalog_student_count_json(self, request, tl, one, two, module, extra, prog, timeslot=None): clean_counts = prog.student_counts_by_section_id() resp = HttpResponse(mimetype='application/json') simplejson.dump(clean_counts, resp) return resp
|
bits = UserBit.objects.filter(user=request.user, startdate__lte=now, enddate__gte=now).filter(QTree(verb__below=GetNode("V/Flags/Registration"), qsc__below=prog.anchor['Classes'])).distinct().select_related('qsc', 'verb') sections = ClassSection.objects.filter(anchor__in=[b.qsc for b in bits]).distinct() status_dict = defaultdict(list) sections_dict = {} for b in bits: status_dict[b.qsc.id].append(b.verb.get_uri().replace('V/Flags/Registration/', '')) for sec in sections: sections_dict[sec.anchor.id] = sec section_statuses = {} for sec_anchor in sections_dict.keys(): section_statuses[sec_anchor] = status_dict[sec_anchor]
|
reg_bits = StudentRegistration.valid_objects().filter(user=request.user, section__parent_class__parent_program=prog).select_related() reg_bits_data = [ { 'user': b.user.username, 'section_id': b.section_id, 'type': b.relationship.name } for b in reg_bits ]
|
def catalog_registered_classes_json(self, request, tl, one, two, module, extra, prog, timeslot=None): now = datetime.now() bits = UserBit.objects.filter(user=request.user, startdate__lte=now, enddate__gte=now).filter(QTree(verb__below=GetNode("V/Flags/Registration"), qsc__below=prog.anchor['Classes'])).distinct().select_related('qsc', 'verb') sections = ClassSection.objects.filter(anchor__in=[b.qsc for b in bits]).distinct()
|
simplejson.dump(section_statuses, resp)
|
simplejson.dump(reg_bits_data, resp)
|
def catalog_registered_classes_json(self, request, tl, one, two, module, extra, prog, timeslot=None): now = datetime.now() bits = UserBit.objects.filter(user=request.user, startdate__lte=now, enddate__gte=now).filter(QTree(verb__below=GetNode("V/Flags/Registration"), qsc__below=prog.anchor['Classes'])).distinct().select_related('qsc', 'verb') sections = ClassSection.objects.filter(anchor__in=[b.qsc for b in bits]).distinct()
|
if get_user is None or ESPUser is None or get_user_django is None:
|
if get_user is None or ESPUser is None:
|
def __get__(self, request, obj_type=None): global get_user_django, ESPUser if not hasattr(request, '_cached_user'): if get_user is None or ESPUser is None or get_user_django is None: from django.contrib.auth import get_user as get_user_django from esp.users.models import ESPUser from esp.utils.get_user import get_user
|
from esp.utils.get_user import get_user
|
def __get__(self, request, obj_type=None): global get_user_django, ESPUser if not hasattr(request, '_cached_user'): if get_user is None or ESPUser is None or get_user_django is None: from django.contrib.auth import get_user as get_user_django from esp.users.models import ESPUser from esp.utils.get_user import get_user
|
|
def add_section(self, duration=0.0, status=0):
|
def add_section(self, duration=None, status=None):
|
def add_section(self, duration=0.0, status=0): """ Add a ClassSection belonging to this class. Can be run multiple times. """ section_index = self.sections.count() + 1 new_section = ClassSection() new_section.parent_class = self new_section.duration = '%.4f' % duration new_section.anchor = DataTree.get_by_uri(self.anchor.get_uri() + '/Section' + str(section_index), create=True) new_section.status = status new_section.save() self.sections.add(new_section) self._sections = None return new_section
|
print self.u.__dict__ print self.u.groups.all()
|
def testAcctCreate(self): self.u=User( first_name='bob', last_name='jones', username='bjones', email='[email protected]', # is_staff=True, ) self.u.set_password('123!@#') self.u.save() self.group=Group(name='Test Group') self.group.save() self.u.groups.add(self.group) self.assertEquals(User.objects.get(username='bjones'), self.u) self.assertEquals(Group.objects.get(name='Test Group'), self.group) print self.u.__dict__ print self.u.groups.all()
|
|
retVal = bool(self.filter(QTree(**{col_filter: node_id}), user = user))
|
now = datetime.datetime.now() retVal = bool(self.filter(QTree(**{col_filter: node_id}), user = user, startdate__lte=now, enddate__gte=now))
|
def user_has_TYPE(self, user, node, node_type='qsc'): """ Returns true if the user has the verb anywhere. False otherwise. """ node_id = getattr(node, 'id', node) col_filter = '%s__above' % node_type cache_key = 'has_%s__%s' % (node_type, node_id)
|
if format == 'html':
|
if file_type == 'html':
|
def studentschedules(self, request, tl, one, two, module, extra, prog, onsite=False): """ generate student schedules """ context = {'module': self }
|
return HttpResponseRedirect("app_questions")
|
return HttpResponseRedirect(newclass.parent_program.get_teach_url() + "app_questions")
|
def makeaclass(self, request, tl, one, two, module, extra, prog, newclass = None): # this is ugly...but it won't recurse and falls # back to @meets_deadline's behavior appropriately if newclass is None and not self.deadline_met(): return meets_deadline(lambda: True)(self, request, tl, one, two, module)
|
", ".join([t.name() for t in cls.teachers()]),
|
", ".join([smart_str(t.name()) for t in cls.teachers()]),
|
def all_classes_spreadsheet(self, request, tl, one, two, module, extra, prog): import csv from django.http import HttpResponse from django.utils.encoding import smart_str
|
cls.message_for_directors, cls.prereqs, cls.directors_notes,
|
smart_str(cls.message_for_directors), smart_str(cls.prereqs), smart_str(cls.directors_notes),
|
def all_classes_spreadsheet(self, request, tl, one, two, module, extra, prog): import csv from django.http import HttpResponse from django.utils.encoding import smart_str
|
[section.parent_class.message_for_directors] + \
|
[smart_str(section.parent_class.message_for_directors)] + \
|
def needs_resource(resname, section): if section.getResourceRequests().filter(res_type__name=resname): return 'Y' else: return ' '
|
'anchor': ('AjaxForeignKey', ["orm['datatree.DataTree']"], {}),
|
'anchor': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['datatree.DataTree']"}),
|
def backwards(self, orm): # Deleting model 'StudentClassRegModuleInfo' db.delete_table('modules_studentclassregmoduleinfo') # Deleting model 'RemoteProfile' db.delete_table('modules_remoteprofile') # Deleting model 'ClassRegModuleInfo' db.delete_table('modules_classregmoduleinfo') # Deleting model 'SATPrepTeacherModuleInfo' db.delete_table('modules_satprepteachermoduleinfo') # Deleting model 'ProgramModuleObj' db.delete_table('modules_programmoduleobj') # Deleting model 'CreditCardModuleInfo' db.delete_table('modules_creditcardmoduleinfo') # Deleting model 'SATPrepAdminModuleInfo' db.delete_table('modules_satprepadminmoduleinfo') # Deleting model 'DBReceipt' db.delete_table('modules_dbreceipt') # Dropping ManyToManyField 'RemoteProfile.volunteer_times' db.delete_table('modules_remoteprofile_volunteer_times') # Dropping ManyToManyField 'RemoteProfile.bus_runs' db.delete_table('modules_remoteprofile_bus_runs')
|
'parent': ('AjaxForeignKey', ["orm['datatree.DataTree']"], {'related_name': "'child_set'", 'null': 'True', 'blank': 'True'}),
|
'parent': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'child_set'", 'null': 'True', 'to': "orm['datatree.DataTree']"}),
|
def backwards(self, orm): # Deleting model 'StudentClassRegModuleInfo' db.delete_table('modules_studentclassregmoduleinfo') # Deleting model 'RemoteProfile' db.delete_table('modules_remoteprofile') # Deleting model 'ClassRegModuleInfo' db.delete_table('modules_classregmoduleinfo') # Deleting model 'SATPrepTeacherModuleInfo' db.delete_table('modules_satprepteachermoduleinfo') # Deleting model 'ProgramModuleObj' db.delete_table('modules_programmoduleobj') # Deleting model 'CreditCardModuleInfo' db.delete_table('modules_creditcardmoduleinfo') # Deleting model 'SATPrepAdminModuleInfo' db.delete_table('modules_satprepadminmoduleinfo') # Deleting model 'DBReceipt' db.delete_table('modules_dbreceipt') # Dropping ManyToManyField 'RemoteProfile.volunteer_times' db.delete_table('modules_remoteprofile_volunteer_times') # Dropping ManyToManyField 'RemoteProfile.bus_runs' db.delete_table('modules_remoteprofile_bus_runs')
|
'user': ('AjaxForeignKey', ["orm['auth.User']"], {'null': 'True', 'blank': 'True'}),
|
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'}),
|
def backwards(self, orm): # Deleting model 'StudentClassRegModuleInfo' db.delete_table('modules_studentclassregmoduleinfo') # Deleting model 'RemoteProfile' db.delete_table('modules_remoteprofile') # Deleting model 'ClassRegModuleInfo' db.delete_table('modules_classregmoduleinfo') # Deleting model 'SATPrepTeacherModuleInfo' db.delete_table('modules_satprepteachermoduleinfo') # Deleting model 'ProgramModuleObj' db.delete_table('modules_programmoduleobj') # Deleting model 'CreditCardModuleInfo' db.delete_table('modules_creditcardmoduleinfo') # Deleting model 'SATPrepAdminModuleInfo' db.delete_table('modules_satprepadminmoduleinfo') # Deleting model 'DBReceipt' db.delete_table('modules_dbreceipt') # Dropping ManyToManyField 'RemoteProfile.volunteer_times' db.delete_table('modules_remoteprofile_volunteer_times') # Dropping ManyToManyField 'RemoteProfile.bus_runs' db.delete_table('modules_remoteprofile_bus_runs')
|
'user': ('AjaxForeignKey', ["orm['auth.User']"], {'null': 'True', 'blank': 'True'})
|
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'})
|
def backwards(self, orm): # Deleting model 'StudentClassRegModuleInfo' db.delete_table('modules_studentclassregmoduleinfo') # Deleting model 'RemoteProfile' db.delete_table('modules_remoteprofile') # Deleting model 'ClassRegModuleInfo' db.delete_table('modules_classregmoduleinfo') # Deleting model 'SATPrepTeacherModuleInfo' db.delete_table('modules_satprepteachermoduleinfo') # Deleting model 'ProgramModuleObj' db.delete_table('modules_programmoduleobj') # Deleting model 'CreditCardModuleInfo' db.delete_table('modules_creditcardmoduleinfo') # Deleting model 'SATPrepAdminModuleInfo' db.delete_table('modules_satprepadminmoduleinfo') # Deleting model 'DBReceipt' db.delete_table('modules_dbreceipt') # Dropping ManyToManyField 'RemoteProfile.volunteer_times' db.delete_table('modules_remoteprofile_volunteer_times') # Dropping ManyToManyField 'RemoteProfile.bus_runs' db.delete_table('modules_remoteprofile_bus_runs')
|
'signup_verb': ('AjaxForeignKey', ["orm['datatree.DataTree']"], {'default': " lambda :GetNode(REG_VERB_BASE+'/Enrolled')"}),
|
'signup_verb': ('django.db.models.fields.related.ForeignKey', [], {'default': "orm['datatree.DataTree'].objects.get(pk=30043)", 'to': "orm['datatree.DataTree']"}),
|
def backwards(self, orm): # Deleting model 'StudentClassRegModuleInfo' db.delete_table('modules_studentclassregmoduleinfo') # Deleting model 'RemoteProfile' db.delete_table('modules_remoteprofile') # Deleting model 'ClassRegModuleInfo' db.delete_table('modules_classregmoduleinfo') # Deleting model 'SATPrepTeacherModuleInfo' db.delete_table('modules_satprepteachermoduleinfo') # Deleting model 'ProgramModuleObj' db.delete_table('modules_programmoduleobj') # Deleting model 'CreditCardModuleInfo' db.delete_table('modules_creditcardmoduleinfo') # Deleting model 'SATPrepAdminModuleInfo' db.delete_table('modules_satprepadminmoduleinfo') # Deleting model 'DBReceipt' db.delete_table('modules_dbreceipt') # Dropping ManyToManyField 'RemoteProfile.volunteer_times' db.delete_table('modules_remoteprofile_volunteer_times') # Dropping ManyToManyField 'RemoteProfile.bus_runs' db.delete_table('modules_remoteprofile_bus_runs')
|
def is_morphed(self, request):
|
def is_morphed(self, request=None): if not request: request = get_current_request()
|
def is_morphed(self, request): return 'user_morph' in request.session
|
if not self.is_morphed():
|
if not self.is_morphed(request):
|
def get_old(self, request): if not self.is_morphed(): return False return ESPUser.objects.get(id=request.session['user_morph']['olduser_id'])
|
if hasattr(self, 'program'): program = self.program elif isinstance(self.module, ProgramModuleObj): program = self.module.program else: raise ESPError("Can't find program from ClassRegModuleInfo") return range( 1, program.getTimeSlots().count()+1 )
|
return range( 1, self.get_program().getTimeSlots().count()+1 )
|
def allowed_sections_actual_get(self): if self.allowed_sections: return self.allowed_sections_ints_get() else: # Unfortunately, it turns out the ProgramModule system does obscene # things with __dict__, so the class specification up there is a # blatant lie. Why the designer didn't think of giving two # different fields different names is a mystery sane people have no # hope of fathoming. (Seriously, these models are INTENDED to be # subclassed together with ProgramModuleObj! What were you # thinking!?) # # see ProgramModuleObj.module, ClassRegModuleInfo.module, and # ProgramModuleObj.fixExtensions # # TODO: Look into renaming the silly field and make sure no black # magic depends on it if hasattr(self, 'program'): program = self.program elif isinstance(self.module, ProgramModuleObj): # Sadly, this probably never happens, but this function is # going to work when called by a sane person, dammit! program = self.module.program else: raise ESPError("Can't find program from ClassRegModuleInfo") return range( 1, program.getTimeSlots().count()+1 )
|
if self.module.program.grade_min: min_grade = self.program.grade_min if self.module.program.grade_max: max_grade = self.program.grade_max
|
if self.get_program().grade_min: min_grade = self.get_program().grade_min if self.get_program().grade_max: max_grade = self.get_program().grade_max
|
def getClassGrades(self): min_grade, max_grade = (6, 12) if self.module.program.grade_min: min_grade = self.program.grade_min if self.module.program.grade_max: max_grade = self.program.grade_max
|
times = self.module.program.getTimeSlots()
|
times = self.get_program().getTimeSlots()
|
def getTimes(self): times = self.module.program.getTimeSlots() return [(str(x.id),x.short_description) for x in times]
|
return self.module.program.getDurations()
|
return self.get_program().getDurations()
|
def getDurations(self): return self.module.program.getDurations()
|
resources = self.module.program.getResources()
|
resources = self.get_program().getResources()
|
def getResources(self): resources = self.module.program.getResources() return [(str(x.id), x.name) for x in resources]
|
base_types = self.module.program.getResourceTypes().filter(priority_default__gt=0)
|
base_types = self.get_program().getResourceTypes().filter(priority_default__gt=0)
|
def getResourceTypes(self, is_global=None): # Get a list of all resource types, excluding the fundamental ones. base_types = self.module.program.getResourceTypes().filter(priority_default__gt=0) if is_global is True: res_types = base_types.filter(program__isnull=True) elif is_global is False: res_types = base_types.filter(program__isnull=False) else: res_types = base_types return [(str(x.id), x.name) for x in res_types]
|
return UserBit.valid_objects().filter(user=self, verb__parent=GetNode("V/Flags/UserRole")).values_list('verb__name', flat=True).distinct()
|
retVal = UserBit.valid_objects().filter(user=self, verb__parent=GetNode("V/Flags/UserRole")).values_list('verb__name', flat=True).distinct() if len(retVal) == 0: UserBit.objects.create(user=self, verb=GetNode("V/Flags/UserRole/Student"), qsc=GetNode("Q")) retVal = UserBit.valid_objects().filter(user=self, verb__parent=GetNode("V/Flags/UserRole")).values_list('verb__name', flat=True).distinct() return retVal
|
def getUserTypes(self): """ Return the set of types for this user """ return UserBit.valid_objects().filter(user=self, verb__parent=GetNode("V/Flags/UserRole")).values_list('verb__name', flat=True).distinct()
|
timeslot_ids.depend_on_m2m(lambda: ClassSection, meeting_times, lambda instance, object: {'self': instance})
|
timeslot_ids.depend_on_m2m(lambda: ClassSection, 'meeting_times', lambda instance, object: {'self': instance})
|
def timeslot_ids(self): return self.meeting_times.all().values_list('id', flat=True)
|
return {'availability': self.getQForUser(Q(resource__event__anchor = self.program_anchor_cached()))}
|
return {'availability': self.getQForUser(qf)}
|
def teachers(self, QObject = False): """ Returns a list of teachers who have indicated at least one segment of teaching availability for this program. """ if QObject is True: return {'availability': self.getQForUser(Q(resource__event__anchor = self.program_anchor_cached()))} teacher_list = Resource.objects.filter(event__anchor=self.program_anchor_cached(), user__isnull=False).values_list('user', flat=True).distinct() return {'availability': teacher_list }#[t['user'] for t in teacher_list]}
|
teacher_list = Resource.objects.filter(event__anchor=self.program_anchor_cached(), user__isnull=False).values_list('user', flat=True).distinct()
|
teacher_list = User.objects.filter(qf).distinct()
|
def teachers(self, QObject = False): """ Returns a list of teachers who have indicated at least one segment of teaching availability for this program. """ if QObject is True: return {'availability': self.getQForUser(Q(resource__event__anchor = self.program_anchor_cached()))} teacher_list = Resource.objects.filter(event__anchor=self.program_anchor_cached(), user__isnull=False).values_list('user', flat=True).distinct() return {'availability': teacher_list }#[t['user'] for t in teacher_list]}
|
def process(self, user, class_id, user_type):
|
def process(self, user, class_id, section_num, user_type):
|
def process(self, user, class_id, user_type): if USE_MAILMAN: self.process_mailman(user, class_id, user_type) else: self.process_nomailman(user, class_id, user_type)
|
self.process_mailman(user, class_id, user_type)
|
self.process_mailman(user, class_id, section_num, user_type)
|
def process(self, user, class_id, user_type): if USE_MAILMAN: self.process_mailman(user, class_id, user_type) else: self.process_nomailman(user, class_id, user_type)
|
self.process_nomailman(user, class_id, user_type)
|
self.process_nomailman(user, class_id, section_num, user_type)
|
def process(self, user, class_id, user_type): if USE_MAILMAN: self.process_mailman(user, class_id, user_type) else: self.process_nomailman(user, class_id, user_type)
|
msgtext = t.render(Context({'user': self,
|
msgtext = t.render(DjangoContext({'user': self,
|
def recoverPassword(self): # generate the ticket, send the email. from django.contrib.sites.models import Site from django.conf import settings
|
if timeslot in s._events:
|
if timeslot in s._events or timeslot == None:
|
def get_section(self, timeslot=None): """ Cache sections for a class. Always use this function to get a class's sections. """
|
print "Couldn't find section!"
|
def get_section(self, timeslot=None): """ Cache sections for a class. Always use this function to get a class's sections. """
|
|
students = User.objects.filter(student_dict['classreg']).distinct()
|
students = ESPUser.objects.filter(student_dict['classreg']).distinct()
|
def generatetags(self, request, tl, one, two, module, extra, prog): """ generate nametags """
|
students = User.objects.filter(student_dict['confirmed']).distinct() students = [ ESPUser(student) for student in students ]
|
students = ESPUser.objects.filter(student_dict['confirmed']).distinct()
|
def generatetags(self, request, tl, one, two, module, extra, prog): """ generate nametags """
|
print 'Added ID %d to list' % cls.id
|
def catalog_cached(self, program, ts=None, force_all=False, initial_queryset=None): """ Return a queryset of classes for view in the catalog.
|
|
print 'Removed duplicate ID %d' % cls.id
|
def catalog_cached(self, program, ts=None, force_all=False, initial_queryset=None): """ Return a queryset of classes for view in the catalog.
|
|
if section.parent_class.class_size_max !=0:
|
if type(section.parent_class.class_size_max) == int:
|
def __init__(self, newclslist): self.clslist = newclslist
|
def clean_phone_cell(self): if self.cleaned_data.get('phone_day','') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.")
|
def clean(self): if Tag.getTag('request_student_phonenum', default='True') != 'False': if self.cleaned_data.get('phone_day','') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.")
|
def clean_phone_cell(self): if self.cleaned_data.get('phone_day','') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") if self.cleaned_data.get('receive_txt_message', False) and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please specify your cellphone number if you ask to receive text messages") return self.cleaned_data['phone_cell']
|
return self.cleaned_data['phone_cell']
|
return self.cleaned_data
|
def clean_phone_cell(self): if self.cleaned_data.get('phone_day','') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") if self.cleaned_data.get('receive_txt_message', False) and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please specify your cellphone number if you ask to receive text messages") return self.cleaned_data['phone_cell']
|
def clean_emerg_phone_cell(self):
|
def clean(self):
|
def clean_emerg_phone_cell(self): if self.cleaned_data.get('emerg_phone_day','') == '' and self.cleaned_data.get('emerg_phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") return self.cleaned_data['emerg_phone_cell']
|
return self.cleaned_data['emerg_phone_cell']
|
return self.cleaned_data
|
def clean_emerg_phone_cell(self): if self.cleaned_data.get('emerg_phone_day','') == '' and self.cleaned_data.get('emerg_phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") return self.cleaned_data['emerg_phone_cell']
|
def clean_guard_phone_cell(self):
|
def clean(self):
|
def clean_guard_phone_cell(self): if self.cleaned_data.get('guard_phone_day','') == '' and self.cleaned_data.get('guard_phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") return self.cleaned_data['guard_phone_cell']
|
return self.cleaned_data['guard_phone_cell']
|
return self.cleaned_data
|
def clean_guard_phone_cell(self): if self.cleaned_data.get('guard_phone_day','') == '' and self.cleaned_data.get('guard_phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") return self.cleaned_data['guard_phone_cell']
|
def clean_studentrep_expl(self): expl = self.cleaned_data['studentrep_expl'].strip() if self.studentrep_error and self.cleaned_data['studentrep'] and expl == '': raise forms.ValidationError("Please enter an explanation above.") return expl
|
def repress_studentrep_expl_error(self): self.studentrep_error = False
|
|
select = SortedDict([( '_num_students', 'SELECT COUNT(DISTICT "users_userbit"."user_id") FROM "users_userbit" WHERE ("users_userbit"."verb_id" = %s AND "users_userbit"."qsc_id" = "datatree_datatree"."id" AND "datatree_datatree"."parent_id" = "program_class"."anchor_id" AND "users_userbit"."startdate" <= %s AND "users_userbit"."enddate" >= %s)'),
|
select = SortedDict([( '_num_students', 'SELECT COUNT(DISTINCT "users_userbit"."user_id") FROM "users_userbit" WHERE ("users_userbit"."verb_id" = %s AND "users_userbit"."qsc_id" = "datatree_datatree"."id" AND "datatree_datatree"."parent_id" = "program_class"."anchor_id" AND "users_userbit"."startdate" <= %s AND "users_userbit"."enddate" >= %s)'),
|
def catalog_cached(self, program, ts=None, force_all=False, initial_queryset=None): """ Return a queryset of classes for view in the catalog.
|
select = SortedDict([( '_count_students', 'SELECT COUNT(*) FROM "users_userbit" WHERE ("users_userbit"."verb_id" = %s AND "users_userbit"."qsc_id" = "program_classsection"."anchor_id" AND "users_userbit"."startdate" <= %s AND "users_userbit"."enddate" >= %s)'),
|
select = SortedDict([( '_count_students', 'SELECT COUNT(DISTINCT "users_userbit"."user_id") FROM "users_userbit" WHERE ("users_userbit"."verb_id" = %s AND "users_userbit"."qsc_id" = "program_classsection"."anchor_id" AND "users_userbit"."startdate" <= %s AND "users_userbit"."enddate" >= %s)'),
|
def prefetch_catalog_data(cls, queryset): """ Take a queryset of a set of ClassSubject's, and annotate each class in it with the '_count_students' and 'event_ids' fields (used internally when available by many functions to save on queries later) """ now = datetime.datetime.now() enrolled_node=GetNode("V/Flags/Registration/Enrolled")
|
if new_data.has_key('optimal_class_size_range_id'):
|
if new_data.has_key('optimal_class_size_range_id') and (new_data['optimal_class_size_range_id'] is not None):
|
def generate_director_mail_context(self, cls, user): new_data = cls.__dict__ print new_data; mail_ctxt = dict(new_data.iteritems()) print mail_ctxt;
|
if user.getClasses(self.parent_program, verbs=[self.parent_program.getModuleExtension('StudentClassRegModuleInfo').signup_verb]).count() == 0:
|
if user.getClasses(self.parent_program, verbs=[self.parent_program.getModuleExtension('StudentClassRegModuleInfo').signup_verb.name]).count() == 0:
|
def cannotAdd(self, user, checkFull=True, request=False, use_cache=True): """ Go through and give an error message if this user cannot add this class to their schedule. """ if not user.isStudent(): return 'You are not a student!' if not self.isAccepted(): return 'This class is not accepted.'
|
if not moduleObj.user.isTeacher() and not moduleObj.user.isAdmin(moduleObj.program) and not (set(moduleObj.getUserTypes()) & set(allowed_teacher_types)):
|
if not moduleObj.user.isTeacher() and not moduleObj.user.isAdmin(moduleObj.program) and not (set(moduleObj.user.getUserTypes()) & set(allowed_teacher_types)):
|
def _checkTeacher(moduleObj, request, *args, **kwargs): allowed_teacher_types = Tag.getTag("allowed_teacher_types", moduleObj.program, default='').split(",") if not moduleObj.user or not moduleObj.user.is_authenticated(): return HttpResponseRedirect('%s?%s=%s' % (LOGIN_URL, REDIRECT_FIELD_NAME, quote(request.get_full_path()))) if not moduleObj.user.isTeacher() and not moduleObj.user.isAdmin(moduleObj.program) and not (set(moduleObj.getUserTypes()) & set(allowed_teacher_types)): return render_to_response('errors/program/notateacher.html', request, (moduleObj.program, 'teach'), {}) return method(moduleObj, request, *args, **kwargs)
|
'list': students_Q & Q(registrationprofile__student_info__graduation_year__lte = yog_12)}
|
'list': students_Q & Q(registrationprofile__student_info__graduation_year__gte = yog_12)}
|
def getLists(self, QObjects=False): from esp.users.models import ESPUser lists = self.students(QObjects) lists.update(self.teachers(QObjects)) learnmodules = self.getModules(None) teachmodules = self.getModules(None)
|
'list': students_Q & Q(registrationprofile__student_info__graduation_year__gt = yog_12)}
|
'list': students_Q & Q(registrationprofile__student_info__graduation_year__lt = yog_12)}
|
def getLists(self, QObjects=False): from esp.users.models import ESPUser lists = self.students(QObjects) lists.update(self.teachers(QObjects)) learnmodules = self.getModules(None) teachmodules = self.getModules(None)
|
verb_list = scrmi.reg_verbs(uris=True)
|
verb_list = [v.name for v in scrmi.reg_verbs()]
|
def getAppliedClasses(self, program=None): # If priority registration is enabled, add in more verbs. if program: scrmi = program.getModuleExtension('StudentClassRegModuleInfo') verb_list = scrmi.reg_verbs(uris=True) else: verb_list = ['Applied'] return self.getClasses(program, verbs=verb_list)
|
db.create_table('shortterm_adlogentry', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('ts', self.gf('django.db.models.fields.DateTimeField')()), ('ipaddr', self.gf('django.db.models.fields.CharField')(max_length=32)), ('agent', self.gf('django.db.models.fields.CharField')(max_length=256)), )) db.send_create_signal('shortterm', ['AdLogEntry'])
|
def forwards(self, orm): # Adding model 'AdLogEntry' db.create_table('shortterm_adlogentry', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('ts', self.gf('django.db.models.fields.DateTimeField')()), ('ipaddr', self.gf('django.db.models.fields.CharField')(max_length=32)), ('agent', self.gf('django.db.models.fields.CharField')(max_length=256)), )) db.send_create_signal('shortterm', ['AdLogEntry'])
|
|
db.delete_table('shortterm_adlogentry')
|
def backwards(self, orm): # Deleting model 'AdLogEntry' db.delete_table('shortterm_adlogentry')
|
|
'shortterm.adlogentry': { 'Meta': {'object_name': 'AdLogEntry'}, 'agent': ('django.db.models.fields.CharField', [], {'max_length': '256'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'ipaddr': ('django.db.models.fields.CharField', [], {'max_length': '32'}), 'ts': ('django.db.models.fields.DateTimeField', [], {}) },
|
def backwards(self, orm): # Deleting model 'AdLogEntry' db.delete_table('shortterm_adlogentry')
|
|
if get_user is None or ESPUser is None:
|
if get_user is None or ESPUser is None or get_user_django is None:
|
def __get__(self, request, obj_type=None): global get_user_django, ESPUser if not hasattr(request, '_cached_user'): if get_user is None or ESPUser is None: from django.contrib.auth import get_user as get_user_django from esp.users.models import ESPUser
|
user.password += "$%d" % userkey
|
user.password += "_%d" % userkey
|
def user_registration(request): """ Registration view -- takes care of users who want to create a new account. """ if request.user.is_authenticated(): return render_to_response('registration/already_logged_in.html', request, request.get_node('Q/Web/myesp'), {}) if request.method == 'POST': form = UserRegForm(request.POST) if form.is_valid(): ## First, check to see if we have any users with the same e-mail if not 'do_reg_no_really' in request.POST and Tag.getTag('ask_about_duplicate_accounts', default='False') == 'True': existing_accounts = User.objects.filter(email=form.cleaned_data['email'], is_active=True).exclude(password='emailuser') if len(existing_accounts) != 0: return render_to_response('registration/newuser.html', request, request.get_node('Q/Web/myesp'), { 'accounts': existing_accounts, 'form': form, 'site': Site.objects.get_current() }) try: user = User.objects.get(email=form.cleaned_data['email'], password = 'emailuser') except User.DoesNotExist: user = User(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']) 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') == 'False': user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password']) login(request, user) return HttpResponseRedirect('/myesp/profile/') else: t = loader.get_template('registration/activation_email.txt') c = Context({'user': user, 'activation_key': userkey, 'site': Site.objects.get_current()}) send_mail("Account Activation", t.render(c), settings.SERVER_EMAIL, [user.email], fail_silently = False) return render_to_response('registration/account_created_activation_required.html', request, request.get_node('Q/Web/myesp'), {'user': user}) else: form = UserRegForm() return render_to_response('registration/newuser.html', request, request.get_node('Q/Web/myesp'),{'form':form})
|
print 'WARNING: Converting UserBit registrations to StudentRegistrations.' print ' This may take several minutes.' for section in ClassSection.objects.all(): convert_student_reg(section) print 'Converted %4d registrations for %s' % (section.num_students(), section)
|
if ClassSection.objects.all().exists(): print 'WARNING: Converting UserBit registrations to StudentRegistrations.' print ' This may take several minutes.' for section in ClassSection.objects.all(): convert_student_reg(section) print 'Converted %4d registrations for %s' % (section.num_students(), section)
|
def forwards(self, orm): # Adding model 'StudentRegistration' db.create_table('program_studentregistration', ( ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)), ('section', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['program.ClassSection'])), ('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'])), ('relationship', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['program.RegistrationType'])), ('start_date', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)), ('end_date', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime(9999, 1, 1, 0, 0))), )) db.send_create_signal('program', ['StudentRegistration'])
|
ans = self.max_class_capacity
|
return self.max_class_capacity
|
def _get_capacity(self, ignore_changes=False): ans = None if self.max_class_capacity is not None: ans = self.max_class_capacity
|
dvips_options += ' -t landscape'
|
dvips_options = ' -t letter,landscape'
|
def gen_latex(texcode, type='pdf', landscape=False): """ Generate the latex code. """ remove_files = True file_base = os.path.join(TEX_TEMP, get_rand_file_base()) if type == 'tex': return HttpResponse(texcode, mimetype='text/plain') # write to the LaTeX file texfile = open(file_base+TEX_EXT, 'w') texfile.write(texcode.encode('utf-8')) texfile.close() file_types = ['pdf','dvi','ps','log','tex','svg','png'] # Get (sometimes-)necessary library files from django.conf import settings import shutil shutil.copy( "%s/esp/3rdparty/pspicture.ps" % settings.PROJECT_ROOT, TEX_TEMP ) # Set dvips options dvips_options = '-t letter' if landscape: dvips_options += ' -t landscape' if type=='pdf': mime = 'application/pdf' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) os.system('cd %s; dvips -t letter %s.dvi' % (TEX_TEMP, file_base)) os.system('cd %s; ps2pdf %s.ps' % (TEX_TEMP, file_base)) if remove_files: os.remove('%s.dvi' % file_base) os.remove('%s.ps' % file_base) elif type=='dvi': mime = 'application/x-dvi' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) elif type=='ps': mime = 'application/postscript' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) os.system('cd %s; dvips %s -t letter -o %s.ps' % (TEX_TEMP, file_base, file_base)) if remove_files: os.remove('%s.dvi' % file_base) elif type=='log': mime = 'text/plain' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) elif type=='svg': mime = 'image/svg+xml' os.system('cd %s; pwd; latex %s.tex' % (TEX_TEMP, file_base)) os.system('cd %s; dvips -t letter %s.dvi' % (TEX_TEMP, file_base)) os.system('cd %s; ps2pdf %s.ps' % (TEX_TEMP, file_base)) os.system('cd %s; inkscape %s.pdf -l %s.svg' % (TEX_TEMP, file_base, file_base)) if remove_files: os.remove('%s.dvi' % file_base) os.remove('%s.ps' % file_base) os.remove('%s.pdf' % file_base) elif type=='png': mime = 'application/postscript' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) os.system('cd %s; dvips -t letter %s.dvi' % (TEX_TEMP, file_base)) os.system('cd %s; convert %s.ps %s.png' % (TEX_TEMP, file_base, file_base)) if remove_files: os.remove('%s.dvi' % file_base) os.remove('%s.ps' % file_base) else: raise ESPError(), 'Invalid type received for latex generation: %s should be one of %s' % (type, file_types) try: tex_log_file = open(file_base+'.log') tex_log = tex_log_file.read() tex_log_file.close() if remove_files: os.remove(file_base+'.log') except: tex_log = '' if type != 'log': try: new_file = open(file_base+'.'+type) new_contents = new_file.read() new_file.close() if remove_files: os.remove(file_base+'.'+type) os.remove(file_base+TEX_EXT) except: raise ESPError(), 'Could not read contents of %s. (Hint: try looking at the log file)' % (file_base+'.'+type) if type=='log': new_contents = tex_log return HttpResponse(new_contents, mimetype=mime)
|
os.system('cd %s; dvips -t letter %s.dvi' % (TEX_TEMP, file_base))
|
os.system('cd %s; dvips %s %s.dvi' % (TEX_TEMP, dvips_options, file_base))
|
def gen_latex(texcode, type='pdf', landscape=False): """ Generate the latex code. """ remove_files = True file_base = os.path.join(TEX_TEMP, get_rand_file_base()) if type == 'tex': return HttpResponse(texcode, mimetype='text/plain') # write to the LaTeX file texfile = open(file_base+TEX_EXT, 'w') texfile.write(texcode.encode('utf-8')) texfile.close() file_types = ['pdf','dvi','ps','log','tex','svg','png'] # Get (sometimes-)necessary library files from django.conf import settings import shutil shutil.copy( "%s/esp/3rdparty/pspicture.ps" % settings.PROJECT_ROOT, TEX_TEMP ) # Set dvips options dvips_options = '-t letter' if landscape: dvips_options += ' -t landscape' if type=='pdf': mime = 'application/pdf' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) os.system('cd %s; dvips -t letter %s.dvi' % (TEX_TEMP, file_base)) os.system('cd %s; ps2pdf %s.ps' % (TEX_TEMP, file_base)) if remove_files: os.remove('%s.dvi' % file_base) os.remove('%s.ps' % file_base) elif type=='dvi': mime = 'application/x-dvi' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) elif type=='ps': mime = 'application/postscript' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) os.system('cd %s; dvips %s -t letter -o %s.ps' % (TEX_TEMP, file_base, file_base)) if remove_files: os.remove('%s.dvi' % file_base) elif type=='log': mime = 'text/plain' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) elif type=='svg': mime = 'image/svg+xml' os.system('cd %s; pwd; latex %s.tex' % (TEX_TEMP, file_base)) os.system('cd %s; dvips -t letter %s.dvi' % (TEX_TEMP, file_base)) os.system('cd %s; ps2pdf %s.ps' % (TEX_TEMP, file_base)) os.system('cd %s; inkscape %s.pdf -l %s.svg' % (TEX_TEMP, file_base, file_base)) if remove_files: os.remove('%s.dvi' % file_base) os.remove('%s.ps' % file_base) os.remove('%s.pdf' % file_base) elif type=='png': mime = 'application/postscript' os.system('cd %s; latex %s.tex' % (TEX_TEMP, file_base)) os.system('cd %s; dvips -t letter %s.dvi' % (TEX_TEMP, file_base)) os.system('cd %s; convert %s.ps %s.png' % (TEX_TEMP, file_base, file_base)) if remove_files: os.remove('%s.dvi' % file_base) os.remove('%s.ps' % file_base) else: raise ESPError(), 'Invalid type received for latex generation: %s should be one of %s' % (type, file_types) try: tex_log_file = open(file_base+'.log') tex_log = tex_log_file.read() tex_log_file.close() if remove_files: os.remove(file_base+'.log') except: tex_log = '' if type != 'log': try: new_file = open(file_base+'.'+type) new_contents = new_file.read() new_file.close() if remove_files: os.remove(file_base+'.'+type) os.remove(file_base+TEX_EXT) except: raise ESPError(), 'Could not read contents of %s. (Hint: try looking at the log file)' % (file_base+'.'+type) if type=='log': new_contents = tex_log return HttpResponse(new_contents, mimetype=mime)
|
new_kwargs = {} if 'extra' in kwargs: extra = kwargs['extra'] else: extra = 'pdf' return module.studentschedules(request, args[0], args[1], args[2], args[3], extra, args[5], onsite=True, format=format)
|
return module.studentschedules(request, *args, **kwargs)
|
def studentschedule(self, request, *args, **kwargs): # tl, one, two, module, extra, prog format = 'pdf' if 'format' in request.GET: format = request.GET['format'].lower() request.GET = {'op':'usersearch', 'userid': str(self.user.id) }
|
if self.cleaned_data.get('receive_txt_message', False) and self.cleaned_data.get('phone_cell','') == '':
|
if self.cleaned_data.get('receive_txt_message', '') == '' and self.cleaned_data.get('phone_cell','') == '':
|
def clean_phone_cell(self): if self.cleaned_data.get('phone_day','') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") if self.cleaned_data.get('receive_txt_message', False) and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please specify your cellphone number if you ask to receive text messages") return self.cleaned_data['phone_cell']
|
if self.cleaned_data.get('receive_txt_message', False) and self.cleaned_data.get('phone_cell','') == '':
|
if self.cleaned_data.get('receive_txt_message', '') != '' and self.cleaned_data.get('phone_cell','') == '':
|
def clean(self): super(UserContactForm, self).clean() if Tag.getTag('request_student_phonenum', default='True') != 'False': if self.cleaned_data.get('phone_day','') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") if self.cleaned_data.get('receive_txt_message', False) and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please specify your cellphone number if you ask to receive text messages.") return self.cleaned_data
|
return User.objects.filter(id = -1)
|
return ESPUser.objects.filter(id = -1)
|
def students_union(self, QObject = False): import operator if len(self.students().values()) == 0: if QObject: return Q(id = -1) else: return User.objects.filter(id = -1) union = reduce(operator.or_, [x for x in self.students(True).values() ]) if QObject: return union else: return User.objects.filter(union).distinct()
|
return User.objects.filter(union).distinct()
|
return ESPUser.objects.filter(union).distinct()
|
def students_union(self, QObject = False): import operator if len(self.students().values()) == 0: if QObject: return Q(id = -1) else: return User.objects.filter(id = -1) union = reduce(operator.or_, [x for x in self.students(True).values() ]) if QObject: return union else: return User.objects.filter(union).distinct()
|
if Tag.getTag("allowed_student_types", target=self.parent_program) or \ user.getGrade() < self.grade_min or \ user.getGrade() > self.grade_max: if not UserBit.UserHasPerms(user = user, qsc = self.anchor, verb = verb_override): return 'You are not in the requested grade range for this class.'
|
if not Tag.getTag("allowed_student_types", target=self.parent_program): if user.getGrade() < self.grade_min or \ user.getGrade() > self.grade_max: if not UserBit.UserHasPerms(user = user, qsc = self.anchor, verb = verb_override): return 'You are not in the requested grade range for this class.'
|
def cannotAdd(self, user, checkFull=True, request=False, use_cache=True): """ Go through and give an error message if this user cannot add this class to their schedule. """ if not user.isStudent() and not Tag.getTag("allowed_student_types", target=self.parent_program): return 'You are not a student!' if not self.isAccepted(): return 'This class is not accepted.'
|
return self.makeaclass(request, tl, one, two, module, extra, prog, cls)
|
return self.makeaclass_logic(request, tl, one, two, module, extra, prog, cls)
|
def editclass(self, request, tl, one, two, module, extra, prog): try: int(extra) except: raise ESPError("False"), "Invalid integer for class ID!"
|
global get_user_django, ESPUser
|
global get_user_django, ESPUser, get_user
|
def __get__(self, request, obj_type=None): global get_user_django, ESPUser if not hasattr(request, '_cached_user'): if get_user is None or ESPUser is None or get_user_django is None: from django.contrib.auth import get_user as get_user_django from esp.users.models import ESPUser from esp.utils.get_user import get_user
|
src = loader.find_template_source(filepath)[0] src_lines = src.lstrip('\n').split('\n') src = src_lines[0] + '\n{% load latex %}' + '\n'.join(src_lines[1:]) t = Template(src)
|
t = loader.get_template(filepath)
|
def render_to_latex(filepath, context_dict=None, filetype='pdf', landscape=None): """ Render some tex source to latex. This will run the latex interpreter and generate the necessary file type (either pdf, tex, ps, dvi, or a log file) """ from django.template import Context, Template, loader ## aseering 8-19-2010: Yes, this should be Context, not RequestContext from django.conf import settings if context_dict is None: context_dict = {} # This is a hack to satisfy Django's requirement that the 'extends' tag come first. # So, if you make a template, put the 'extends' tag in the first line. # Especially if it's for Latex. :) if isinstance(filepath, Template): t = filepath else: src = loader.find_template_source(filepath)[0] src_lines = src.lstrip('\n').split('\n') src = src_lines[0] + '\n{% load latex %}' + '\n'.join(src_lines[1:]) t = Template(src) context = Context(context_dict) context['MEDIA_ROOT'] = settings.MEDIA_ROOT context['file_type'] = filetype rendered_source = t.render(context) # Autodetect landscape mode if 'landscape' is in the first 10 lines of output top_lines = rendered_source.split('\n')[:10] if landscape is None: if 'landscape' in '\n'.join(top_lines): landscape=True return gen_latex(rendered_source, filetype, landscape)
|
self.cache['friendly_times_%s % raw'] = txtTimes
|
self.cache['friendly_times_%s' % raw] = txtTimes
|
def friendly_times(self, use_cache=False, raw=False): """ Return a friendlier, prettier format for the times.
|
return True
|
return oldclasses.values_list('id', flat=True)
|
def clearslot_logic(self, request, tl, one, two, module, extra, prog): """ Clear the specified timeslot from a student registration and return True if there are no errors """ # The registration verb can be anything under this. v_registered_base = request.get_node('V/Flags/Registration') # This query just gets worse and worse. -Michael # Maybe a little better with QTree? -Axiak oldclasses = ClassSection.objects.filter( QTree(anchor__userbit_qsc__verb__below = v_registered_base), meeting_times=extra, parent_class__parent_program = self.program, anchor__userbit_qsc__user = self.user).distinct() # Narrow this down to one class if we're using the priority system. if request.GET.has_key('sec_id'): oldclasses = oldclasses.filter(id=request.GET['sec_id']) #classes = self.user.getEnrolledClasses() class_ids = [c.parent_class.id for c in oldclasses] for cls in oldclasses: # Make sure deletion doesn't violate any class implications before proceeding for implication in ClassImplication.objects.filter(cls__in=class_ids, enforce=True, parent__isnull=True): if implication.fails_implication(self.user, without_classes=set([cls.id])): raise ESPError(False), 'This class is required for your %s class "%s"! To remove this class, please remove the one that requires it through <a href="%sstudentreg">%s Student Registration</a>.' % (implication.cls.parent_program.niceName(), implication.cls.title(), implication.cls.parent_program.get_learn_url(), implication.cls.parent_program.niceName()) cls.unpreregister_student(self.user) # Undo auto-registrations of sections for implication in ClassImplication.objects.filter(cls=cls, enforce=True): for auto_class in ClassSubject.objects.filter(id__in=implication.member_id_ints): auto_class.unpreregister_student(self.user) return True
|
if self.cleaned_data.get('receive_txt_message', '') != '' and self.cleaned_data.get('phone_cell','') == '':
|
if self.cleaned_data.get('receive_txt_message', None) and self.cleaned_data.get('phone_cell','') == '':
|
def clean(self): super(UserContactForm, self).clean() if Tag.getTag('request_student_phonenum', default='True') != 'False': if self.cleaned_data.get('phone_day','') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") if self.cleaned_data.get('receive_txt_message', '') != '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please specify your cellphone number if you ask to receive text messages.") return self.cleaned_data
|
if user:
|
if user and hasattr(user, 'id') and user.id is not None:
|
def inline_cache_key(input_anchor, path, user=None): if user: return '%s_%s_%d_inline' % (input_anchor.id, path, user.id) else: return '%s_%s_anon_inline' % (input_anchor.id, path)
|
return cmp(self.title, other.title)
|
return cmp(self.title(), other.title())
|
def __cmp__(self, other): selfevent = self.firstBlockEvent() otherevent = other.firstBlockEvent()
|
return render_to_response("users/userview.html", request, GetNode("Q/Web"), { 'user': user, 'teacherbio': teacherbio } )
|
return render_to_response("users/userview.html", request, GetNode("Q/Web"), { 'user': user, 'teacherbio': teacherbio, 'domain': SITE_INFO[1] } )
|
def userview(request): """ Render a template displaying all the information about the specified user """ try: user = ESPUser.objects.get(username=request.GET['username']) except: raise ESPError(False), "Sorry, can't find anyone with that username." teacherbio = TeacherBio.getLastBio(user) if not teacherbio.picture: teacherbio.picture = 'uploaded/not-available.jpg' return render_to_response("users/userview.html", request, GetNode("Q/Web"), { 'user': user, 'teacherbio': teacherbio } )
|
if self.cleaned_data.get('receive_txt_message', '') == '' and self.cleaned_data.get('phone_cell','') == '':
|
if self.cleaned_data.get('receive_txt_message', False) and self.cleaned_data.get('phone_cell','') == '':
|
def clean_phone_cell(self): if self.cleaned_data.get('phone_day','') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") if self.cleaned_data.get('receive_txt_message', '') == '' and self.cleaned_data.get('phone_cell','') == '': raise forms.ValidationError("Please specify your cellphone number if you ask to receive text messages") return self.cleaned_data['phone_cell']
|
return self.cleaned_data['phone_cell']
|
return self.cleaned_data['emerg_phone_cell']
|
def clean_emerg_phone_cell(self): if self.cleaned_data.get('emerg_phone_day','') == '' and self.cleaned_data.get('emerg_phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") return self.cleaned_data['phone_cell']
|
return self.cleaned_data['phone_cell']
|
return self.cleaned_data['guard_phone_cell']
|
def clean_guard_phone_cell(self): if self.cleaned_data.get('guard_phone_day','') == '' and self.cleaned_data.get('guard_phone_cell','') == '': raise forms.ValidationError("Please provide either a day phone or cell phone.") return self.cleaned_data['phone_cell']
|
self.make_class_happen(cls, user, reg_form, resource_formset, restype_formset)
|
self.make_class_happen(cls, user, reg_form, resource_formset, restype_formset, editing=True)
|
def editclass(self, user, reg_data, clsid, form_class=TeacherClassRegForm): reg_form, resource_formset, restype_formset = self.get_forms(reg_data, form_class=form_class)
|
def make_class_happen(self, cls, user, reg_form, resource_formset, restype_formset):
|
def make_class_happen(self, cls, user, reg_form, resource_formset, restype_formset, editing=False):
|
def make_class_happen(self, cls, user, reg_form, resource_formset, restype_formset): self.set_class_data(cls, reg_form) self.update_class_sections(cls, int(reg_form.cleaned_data['num_sections'])) self.associate_teacher_with_class(cls, user) self.add_rsrc_requests_to_class(cls, resource_formset, restype_formset) cls.propose() cls.update_cache()
|
self.associate_teacher_with_class(cls, user)
|
if not editing: self.associate_teacher_with_class(cls, user)
|
def make_class_happen(self, cls, user, reg_form, resource_formset, restype_formset): self.set_class_data(cls, reg_form) self.update_class_sections(cls, int(reg_form.cleaned_data['num_sections'])) self.associate_teacher_with_class(cls, user) self.add_rsrc_requests_to_class(cls, resource_formset, restype_formset) cls.propose() cls.update_cache()
|
return needs_teacher(self.profile)(self, request, tl, one, two, module, extra, prog)
|
return needs_teacher(self.profile)(self, request, tl, one, two, module, extra)
|
def profile(self, request, tl, one, two, module, extra, prog): """ Display the registration profile page, the page that contains the contact information for a student, as attached to a particular program """
|
return needs_student(self.profile)(self, request, tl, one, two, module, extra, prog)
|
return needs_student(self.profile)(self, request, tl, one, two, module, extra)
|
def profile(self, request, tl, one, two, module, extra, prog): """ Display the registration profile page, the page that contains the contact information for a student, as attached to a particular program """
|
cls.get_sections = list(cls.get_sections()) for sec in cls.get_sections:
|
cls._sections = list(cls.get_sections()) for sec in cls._sections:
|
def render_class_core(cls): prog = cls.parent_program # Show enrollment? show_enrollment = prog.visibleEnrollments() # Okay, chose a program? Good. Now fetch the color from its hiding place and format it... colorstring = prog.getColor() if colorstring is not None: colorstring = ' background-color:#' + colorstring + ';' # HACK for Harvard HSSP -- show application counts with enrollment if cls.studentappquestion_set.count(): cls.get_sections = list(cls.get_sections()) for sec in cls.get_sections: sec.num_apps = sec.num_students(verbs=['/Applied']) return {'class': cls, 'isfull': (cls.isFull()), 'colorstring': colorstring, 'show_enrollment': show_enrollment }
|
self.config = pulp.util.loadConfig(config_file)
|
self.config = pulp.util.load_config(config_file)
|
def setUp(self): config_file = os.path.join(srcdir, "../etc/pulp/pulp.ini") self.config = pulp.util.loadConfig(config_file) self.rapi = RepoApi(self.config) self.rapi.clean()
|
return getattr(submod, core)
|
return getattr(submod, name)
|
def _load_core(self, name): mod = __import__('pulp.client.core.', globals(), locals(), [name]) try: submod = getattr(mod, name) except AttributeError: return None return getattr(submod, core)
|
help = _('consumer id (required)')
|
def setup_parser(self): default = None help = _('consumer id (required)') consumerid = self.getconsumerid() if consumerid is not None: default = consumerid help = SUPPRESS_HELP self.parser.add_option("--consumerid", dest="consumerid", default=default, help=help) self.parser.add_option("--repoid", dest="repoid", help=_("repository id")) self.parser.add_option("--type", dest="type", action="append", help=_("type of errata to lookup; supported types: security, bugfix, enhancement"))
|
|
self.parser.add_option("--consumerid", dest="consumerid", default=default, help=help)
|
self.parser.add_option("--consumerid", dest="consumerid", default=default, help=_('This option is required if a consumer doesn\'t exist locally.'))
|
def setup_parser(self): default = None help = _('consumer id (required)') consumerid = self.getconsumerid() if consumerid is not None: default = consumerid help = SUPPRESS_HELP self.parser.add_option("--consumerid", dest="consumerid", default=default, help=help) self.parser.add_option("--repoid", dest="repoid", help=_("repository id")) self.parser.add_option("--type", dest="type", action="append", help=_("type of errata to lookup; supported types: security, bugfix, enhancement"))
|
print errata
|
print(" , ".join(errata))
|
def run(self): consumerid = self.opts.consumerid repoid = self.opts.repoid if not (consumerid or repoid): system_exit(os.EX_USAGE, _("A consumer or a repository is required to lookup errata")) if repoid: errata = self.rconn.errata(repoid, self.opts.type) elif consumerid: errata = self.cconn.errata(consumerid, self.opts.type) if not errata: system_exit(os.EX_OK, _("No errata available to list")) print errata
|
errata['status'], effected_pkgs, errata['references'])
|
errata['status'], ",\n\t\t\t".join(effected_pkgs), ref)
|
def run(self): id = self.get_required_option('id') errata = self.econn.erratum(id) effected_pkgs = [str(pinfo['filename']) for pkg in errata['pkglist'] for pinfo in pkg['packages']] print constants.ERRATA_INFO % (errata['id'], errata['title'], errata['description'], errata['type'], errata['issued'], errata['updated'], errata['version'], errata['release'], errata['status'], effected_pkgs, errata['references'])
|
self.rapi.add_package_to_group(repo["id"], pkg_group["id"], "test_package_name")
|
self.rapi.add_packages_to_group(repo["id"], pkg_group["id"], "test_package_name")
|
def test_create_groups_metadata(self): repo_path = os.path.join(self.data_path, "no_groups_repo") repo = self.rapi.create("test_create_groups_metadata_id", 'test_import_groups_data_id', 'i386', 'local:file://%s' % (repo_path)) self.rapi.sync(repo["id"]) found = self.rapi.packagegroups(repo['id']) self.assertTrue(len(found) == 0) self.assertTrue(repo["group_xml_path"] == "") self.assertTrue(repo["group_gz_xml_path"] == "") pkg_group = self.rapi.create_packagegroup(repo["id"], "test_group", "test_group_name", "test description") self.rapi.add_package_to_group(repo["id"], pkg_group["id"], "test_package_name") # Update repo object so we can test that group_xml_path was set repo = self.rapi.repository(repo["id"]) self.assertTrue(repo["group_xml_path"] != "") comps = yum.comps.Comps() comps.add(repo["group_xml_path"]) groups = comps.get_groups() self.assertTrue(len(groups) == 1) self.assertTrue(groups[0].groupid == pkg_group["id"]) self.assertTrue(groups[0].name == pkg_group["name"]) self.assertTrue("test_package_name" in groups[0].default_packages) self.assertTrue("test_package_name" not in groups[0].mandatory_packages)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.