def users_for_questionnaire(questionnaire): account_model = _get_model_from_auth_profile_module() subjects = [ x for x in account_model.objects.filter(questionnaires__id=questionnaire) if x.subject is not None and x.subject.state == "active" ] return subjects
def authenticate(self, token=None, user=None): """ Se non posso cercare il @token nel DB (il modello non ha il campo token) ed ho @user provo default_token_generator.check_token Se posso cercarlo sul DB: 1 - lo trovo: + @user passato deve corrispondere al @token trovato sul DB 2 - non lo trovo: + provo usando default_token_generator.check_token Se @user e' passato ma non ha l'attributo last_login (usato nel chek_token), non autentico. """ logger.debug("authenticate[%s] ( token=%s , user=%s )", self, token, user) if token is not None: model = _get_model_from_auth_profile_module() if 'token' in [f.name for f in model._meta.fields]: try: user_profile = model.objects.get(token=token) if user is None and check_random_token_is_valid(token): return user_profile.user elif user == user_profile.user and \ check_random_token_is_valid(token): return user except model.MultipleObjectsReturned: logger.error("token[\"%s\"] is not unique", token) return None except model.DoesNotExist: try: if user is not None and \ default_token_generator.\ check_token(user, token): logger.debug( "token DoenNotExist but " "(user: %s , token: %s) " "is valid, auth OK", user, token) return user except AttributeError, e: logger.error("user[%s] can not be " "authenticate: %s", user, e) else: try: if user is not None and \ default_token_generator\ .check_token(user, token): logger.debug( "model[%s] have not token field " "(user: %s , token: %s) is valid," " auth OK", model, user, token) return user except AttributeError: logger.error("user[%s] can not be authenticate: %s", user, e)
def get_object(self, queyset=None): if self.model is None: self.model = _get_model_from_auth_profile_module() if self.kwargs.get('slug', None) is None and \ self.request.user.is_authenticated(): try: return self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): return None try: return self.model.objects.get( **{self.slug_field: self.kwargs.get('slug', None)}) except: return None
def get_form(self, form_class): logger.debug("Form for current user: %s", form_class(self.request.user).as_p()) if self.slug is None: return form_class(self.request.user, **self.get_form_kwargs()) if self.model is None: self.model = _get_model_from_auth_profile_module() try: account = self.model.objects.get(**{self.slug_field: self.slug}) if not (self.request.user.is_superuser or self.request.user == account.user): account = self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): return form_class(self.request.user, **self.get_form_kwargs()) return form_class(account.user, **self.get_form_kwargs())
def create_subject_account(sender, instance, created, **kwargs): ''' @sender: Account model @instance: account Account model instance ''' # TODO: valuate and make it configurable via settings if isinstance(instance, User): try: account = instance.get_profile() except: return elif isinstance(instance, _get_model_from_auth_profile_module()): account = instance else: logger.error( "create_subject_account signal: sender: %s - instance: %s", sender, instance) return if created: subject, created_subj = Subject.objects.get_or_create( state='active', surname=account.username, givenname=account.fullname, email=account.email) if created_subj: account.subject = subject account.save() else: subject = account.subject if subject is None: account.subject, created_subj = Subject.objects.get_or_create( state='active', surname=account.username, givenname=account.fullname, email=account.email) account.subject.save() account.save() return if account.is_active: subject.state = 'active' else: subject.state = 'inactive' subject.surname = account.username subject.givenname = account.fullname subject.email = account.email subject.save()
class ChangePasswordView(_FormView, GenericProtectedUncacheableView, CaptchableView): model = _get_model_from_auth_profile_module() slug = None slug_field = 'id' password_change_form_class = PasswordChangeForm admin_password_change_form_class = AdminPasswordChangeForm change_done_template_name = 'account/chpsw.html' after_change_password_callback = None def get_initial(self): # initially always empty form return {} def get_form_class(self): if self.request.user.is_superuser: return self.admin_password_change_form_class return self.password_change_form_class def get_form(self, form_class): logger.debug("Form for current user: %s", form_class(self.request.user).as_p()) if self.slug is None: return form_class(self.request.user, **self.get_form_kwargs()) if self.model is None: self.model = _get_model_from_auth_profile_module() try: account = self.model.objects.get(**{self.slug_field: self.slug}) if not (self.request.user.is_superuser or self.request.user == account.user): account = self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): return form_class(self.request.user, **self.get_form_kwargs()) return form_class(account.user, **self.get_form_kwargs()) def get(self, request, *args, **kwargs): if not self.request.user.is_authenticated(): return redirect_to_login(self.request.path) return super(ChangePasswordView, self).get(request, *args, **kwargs) def form_valid(self, form): form.save() _try_callback(self, 'after_change_password_callback') return TemplateResponse(self.request, self.change_done_template_name)
def get_object(self, queryset=None): if self.model is None: self.model = _get_model_from_auth_profile_module() try: account = self.model.objects.get(**{self.slug_field: self.slug}) except (self.model.DoesNotExist, AttributeError): account = None ### TODO: rewite in a simpler way try: current_account = self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): current_account = None if (self.request.user.is_superuser and self.slug) or \ (current_account is not None) and (account == current_account): return account try: return self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): return None
def form_valid(self, form): auth_login(self.request, form.get_user()) _try_callback(self, 'after_login_callback') if self.request.session.test_cookie_worked(): self.request.session.delete_test_cookie() if self.model is None: self.model = _get_model_from_auth_profile_module() if self.current_app is None: self.current_app = self.model.__name__.lower() if self.request.user == form.get_user(): try: self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): self.model(user=self.request.user).save() return HttpResponseRedirect(self.redirect_to)
def form_invalid(self, form): self.request.session.set_test_cookie() current_site = get_current_site(self.request) if self.model is None: self.model = _get_model_from_auth_profile_module() if self.current_app is None: self.current_app = self.model.__name__.lower() context = self.get_context_data( **{ 'form': form, self.redirect_field_name: self.redirect_to, 'site': current_site, 'site_name': current_site.name }) return TemplateResponse(self.request, self.template_name, context, current_app=self.current_app)
class SendInvitation(GenericProtectedView): slug = None slug_field = 'id' account_model = _get_model_from_auth_profile_module() @method_decorator(staff_member_required) def dispatch(self, request, *args, **kwargs): return super(SendInvitation, self).dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): qid = int(kwargs.get('slug', 0)) subjid = kwargs.get('subjid', None) if not subjid: _subjects = self.account_model.objects.filter( questionnaires__id=qid) subjects = [ i.subject for i in _subjects if i.subject is not None and i.subject.state == "active" ] else: subjects = Subject.objects.filter(id=int(subjid), state="active") for i in subjects: runinfo = RunInfo.objects.filter( subject=i, questionset__questionnaire__id=qid) runinfohistory = RunInfoHistory.objects.filter( subject=i, questionnaire__id=qid) if runinfo.count() == 0 and runinfohistory.count() == 0: logger.debug( "il soggetto %s deve ancora compilare il questionario %s: creare il runinfo associato", i.givenname, qid) randomstr = str(''.join( random.sample('abcdefghilmnopqrstuvz0123456789', 10))) new_run = RunInfo( subject=i, random=randomstr, runid=randomstr, questionset=QuestionSet.objects.filter( questionnaire__id=qid).order_by('sortid')[0]) new_run.save() logger.debug("creato per %s", i.givenname) link = Site.objects.get_current().domain + unicode( reverse('questionnaire', args=[randomstr])) try: type_mail = QuestionnaireMails.objects.get( questionnaire__id=qid).invite_mail.type_mail except Exception, e: logger.error( "Missing QuestionnaireMails invite for questionnaire id %s: %s", qid, e) type_mail = INVITATION_SEND_TYPE_MAIL kwargs = { 'type': type_mail, 'mailto': [i.email], i.email: { 'user': i.givenname, 'link': link } } try: SendTypeMail(kwargs) except SendTypeMailError, e: logger.error("In SendInvitation invitation Exc: ", e) elif runinfo.count() > 0 and runinfohistory.count() == 0: logger.debug( "il soggetto %s deve finire di compilare il questionario %s: inviare il runid associato", i.givenname, qid) link = Site.objects.get_current().domain + unicode( reverse('questionnaire', args=[runinfo[0].runid])) try: type_mail = QuestionnaireMails.objects.get( questionnaire__id=qid).remind_mail.type_mail except Exception, e: logger.error( "Missing QuestionnaireMails reminder for questionnaire id %s: %s", qid, e) type_mail = REMINDER_SEND_TYPE_MAIL
surname=account.username, givenname=account.fullname, email=account.email) if created_subj: account.subject = subject account.save() else: subject = account.subject if subject is None: account.subject, created_subj = Subject.objects.get_or_create( state='active', surname=account.username, givenname=account.fullname, email=account.email) account.subject.save() account.save() return if account.is_active: subject.state = 'active' else: subject.state = 'inactive' subject.surname = account.username subject.givenname = account.fullname subject.email = account.email subject.save() # TODO: Fix and do in better way! post_save.connect(create_subject_account, sender=_get_model_from_auth_profile_module())
def form_valid(self, form): form_keys = form.data.keys()[:] new_user = User.objects.create_user(username=form.data['username'], password=form.data['password1'], email=form.data.get('email', None)) # consume username, password1 password2, email pk id user _user_related_to_consume = [ 'username', 'password1', 'password2', 'email', 'password' ] _user_related_to_consume += ['last_login', 'date_joined'] _consume_formfields(form_keys, *_user_related_to_consume) if self.model is None: self.model = _get_model_from_auth_profile_module() account_kwargs = {} _model_field_names = [ f.name for f in self.model._meta.fields if not f.name in ['pk', 'id', 'user'] ] _consume_formfields(form_keys, 'pk', 'id', 'user') for fname in form_keys[:]: if fname in _model_field_names: account_kwargs.update({fname: form.data[fname]}) _consume_formfields(form_keys, fname) try: self.object = new_user.get_profile() except (self.model.DoesNotExist, AttributeError): self.object = self.model(user=new_user, **account_kwargs) self.object.save() else: rows = self.model.objects\ .filter(pk=self.object.pk).update(**account_kwargs) # Using update() we write directly on db and instance associated # to new_user via get_profile() is unchanged, to force get_profile # to refresh it from db delete _profile_cache attr if hasattr(new_user, '_profile_cache'): delattr(new_user, '_profile_cache') assert (rows == 1 or rows == len(account_kwargs) == 0) have_to_save = False if bool(form_keys): # remain some keys try them over User model for k in form_keys[:]: if hasattr(new_user, k): have_to_save = True setattr(new_user, k, form.data[k]) _consume_formfields(form_keys, k) if not self.signup_user_is_active: new_user.is_active = False have_to_save = True if have_to_save: new_user.save() if bool(form_keys): logger.warning("remain some unused form fields: %s", form_keys) if self.login_after_signup and new_user.is_active: u = authenticate(username=form.data['username'], password=form.data['password1']) auth_login(self.request, u) self.new_user = new_user _try_callback(self, 'after_signup_callback') delattr(self, 'new_user') return HttpResponseRedirect(self.get_success_url())
class SignupView(_CreateView, GenericProtectedUncacheableView, CaptchableView): model = _get_model_from_auth_profile_module() template_name = "registration/signup_as_ul.html" user_create_form_class = (SIGNUP_EMAIL_UNIQUENESS and UserCreationEmailUniqueForm or UserCreationForm) formfields_uniqueness = False exclude_formfields = [ 'user', 'password', 'user_permissions', 'is_staff', 'is_superuser', 'is_active', 'groups', 'last_login', 'date_joined' ] additional_exclude_formfields = None require_formfields = (SIGNUP_EMAIL_UNIQUENESS and ['email'] or None) login_after_signup = DO_LOGIN_AFTER_SIGNUP signup_user_is_active = SIGNUP_USER_IS_ACTIVE slug = None success_url = "/" after_signup_callback = None def get_initial(self): return {} def get_form_class(self): if self.form_class is not None: return super(SignupView, self).get_form_class() super_form_k = super(SignupView, self).get_form_class() _uniqueness = self.formfields_uniqueness form_k = generic_formclass_factory([super_form_k, User], fields_uniqueness=_uniqueness, bases=[self.user_create_form_class]) _exclude_formfields = self.exclude_formfields[:] if self.additional_exclude_formfields is not None: _exclude_formfields += self.additional_exclude_formfields[:] for k in _exclude_formfields: if k in form_k.base_fields: del form_k.base_fields[k] if self.require_formfields is not None: for k in self.require_formfields: if k in form_k.base_fields and \ hasattr(form_k.base_fields[k], 'required') and \ not getattr(form_k.base_fields[k], 'required'): form_k.base_fields[k].required = True _maybe_add_captcha(self, form_k.base_fields) return form_k def form_valid(self, form): form_keys = form.data.keys()[:] new_user = User.objects.create_user(username=form.data['username'], password=form.data['password1'], email=form.data.get('email', None)) # consume username, password1 password2, email pk id user _user_related_to_consume = [ 'username', 'password1', 'password2', 'email', 'password' ] _user_related_to_consume += ['last_login', 'date_joined'] _consume_formfields(form_keys, *_user_related_to_consume) if self.model is None: self.model = _get_model_from_auth_profile_module() account_kwargs = {} _model_field_names = [ f.name for f in self.model._meta.fields if not f.name in ['pk', 'id', 'user'] ] _consume_formfields(form_keys, 'pk', 'id', 'user') for fname in form_keys[:]: if fname in _model_field_names: account_kwargs.update({fname: form.data[fname]}) _consume_formfields(form_keys, fname) try: self.object = new_user.get_profile() except (self.model.DoesNotExist, AttributeError): self.object = self.model(user=new_user, **account_kwargs) self.object.save() else: rows = self.model.objects\ .filter(pk=self.object.pk).update(**account_kwargs) # Using update() we write directly on db and instance associated # to new_user via get_profile() is unchanged, to force get_profile # to refresh it from db delete _profile_cache attr if hasattr(new_user, '_profile_cache'): delattr(new_user, '_profile_cache') assert (rows == 1 or rows == len(account_kwargs) == 0) have_to_save = False if bool(form_keys): # remain some keys try them over User model for k in form_keys[:]: if hasattr(new_user, k): have_to_save = True setattr(new_user, k, form.data[k]) _consume_formfields(form_keys, k) if not self.signup_user_is_active: new_user.is_active = False have_to_save = True if have_to_save: new_user.save() if bool(form_keys): logger.warning("remain some unused form fields: %s", form_keys) if self.login_after_signup and new_user.is_active: u = authenticate(username=form.data['username'], password=form.data['password1']) auth_login(self.request, u) self.new_user = new_user _try_callback(self, 'after_signup_callback') delattr(self, 'new_user') return HttpResponseRedirect(self.get_success_url())
class UpdateView(_UpdateView, CaptchableView): model = _get_model_from_auth_profile_module() slug = None exclude_formfields = [ 'user', 'password', 'user_permissions', 'is_staff', 'is_superuser', 'is_active', 'groups', 'last_login', 'date_joined' ] additional_exclude_formfields = None user_change_form_class = UserChangeForm formfields_uniqueness = False require_formfields = None after_update_profile_callback = None def get_success_url(self): if self.success_url: return self.success_url return "" def get_form_class(self): if self.form_class is not None: return super(UpdateView, self).get_form_class() super_form_k = super(UpdateView, self).get_form_class() super_form_k.base_fields = {} _sorted_fields = self.user_change_form_class.base_fields _uniqueness = self.formfields_uniqueness form_k = generic_formclass_factory([], sorted_fields=_sorted_fields, prepend_fields=True, fields_uniqueness=_uniqueness, bases=[super_form_k]) _exclude_formfields = self.exclude_formfields[:] if self.additional_exclude_formfields is not None: _exclude_formfields += self.additional_exclude_formfields[:] for k in _exclude_formfields: if k in form_k.base_fields: del form_k.base_fields[k] if self.require_formfields is not None: for k in self.require_formfields: if k in form_k.base_fields and \ hasattr(form_k.base_fields[k], 'required') and \ not getattr(form_k.base_fields[k], 'required'): form_k.base_fields[k].required = True _maybe_add_captcha(self, form_k.base_fields) return form_k def get_initial(self): if self.object is None: return {} initial = {} rel_fields = [] for f in self.object._meta.fields: if f.rel: rel_fields.insert(0, f) continue initial.update({f.name: getattr(self.object, f.name)}) ## Too much invasive, should respect concrete model properties. ## Also have to prefix according with ## get_form_class / generic_formclass_factory for rel_f in rel_fields: related_obj = getattr(self.object, rel_f.name) for f in related_obj._meta.fields: if f.name in initial: initial.update({ rel_f.name + "_" + f.name: getattr(related_obj, f.name) }) else: initial.update({f.name: getattr(related_obj, f.name)}) return initial def get_object(self, queryset=None): if self.model is None: self.model = _get_model_from_auth_profile_module() try: account = self.model.objects.get(**{self.slug_field: self.slug}) except (self.model.DoesNotExist, AttributeError): account = None ### TODO: rewite in a simpler way try: current_account = self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): current_account = None if (self.request.user.is_superuser and self.slug) or \ (current_account is not None) and (account == current_account): return account try: return self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): return None ## POST related method def form_valid(self, form): ### TODO: put interesting fields in an instance variable list if self.object is None: return redirect_to_login(self.request.path) if form.has_changed(): for k, v in form.data.items(): if not k in form.changed_data: continue if k in [ f.name for f in self.model._meta.fields if not f.name in ['id', 'pk', 'user', 'user_id'] ]: setattr(self.object, k, v) elif k in [ f.name for f in self.object.user._meta.fields if not f.name in ['id', 'pk'] ]: setattr(self.object.user, k, v) self.object.save() _try_callback(self, 'after_update_profile_callback') return HttpResponseRedirect(self.get_success_url())
class ShowGraph(TemplateView, GenericProtectedView): slug = None slug_field = 'id' template_name = 'questionnaire/quest_graph.html' account_model = _get_model_from_auth_profile_module() @method_decorator(staff_member_required) def dispatch(self, request, *args, **kwargs): return super(ShowGraph, self).dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): qid = int(kwargs['slug']) _subjects = self.account_model.objects.filter(questionnaires__id=qid) subjects = [ i.subject for i in _subjects if i.subject is not None and i.subject.state == "active" ] quest_comp = RunInfoHistory.objects.filter(questionnaire__id=qid) comp = quest_comp.count() quest_started = RunInfo.objects.filter( questionset__questionnaire__id=qid) not_comp = quest_started.count() not_invited = len(subjects) - comp - not_comp if not_invited < 0: not_invited = 0 questions = Question.objects.filter(questionset__questionnaire=qid) questions = sorted( questions, key=lambda o: int(re.sub("[^0-9]", "", str(o.number)))) lista = [] lista_percent = [] for i in questions: newdiz = {} newdiz_percent = {} q_type = i.type answers = Answer.objects.filter(question=i) out = [] for ans in answers: # logger.debug(u"Q: %s - A: %s", ans.question, ans.answer) q_type = ans.question.type if ans.answer: anslist = eval(ans.answer) else: anslist = [] if 'choice' not in q_type: # No choices to manage if len(anslist) > 0: choiceval = anslist[0] else: choiceval = '' if not newdiz.get('Open Answer'): newdiz['Open Answer'] = 1 else: newdiz['Open Answer'] += 1 else: if len(anslist) == 0: choiceval = '' elif len(anslist) == 1: # radio, single, yes-no for anselt in anslist: if q_type in [ 'choice-yesno', 'choice-yesnocomment', 'choice-yesnodontknow' ]: choiceval = anselt if not newdiz.get(anselt, None): newdiz[conditional_escape(anselt)] = 1 else: newdiz[conditional_escape(anselt)] += 1 elif isinstance(anselt, list): choiceval = anselt[0] if not newdiz.get('Open Answer', None): newdiz['Open Answer'] = 1 else: newdiz['Open Answer'] += 1 else: choice = Choice.objects.get( question=ans.question, value=anselt) choiceval = choice.value if not newdiz.get(choice.value, None): newdiz[conditional_escape( choice.value)] = 1 else: newdiz[conditional_escape( choice.value)] += 1 else: #mutiple, have to append text in string choiceval = '' for anselt in anslist: if isinstance(anselt, list): # selected altro choiceval = anselt[0] if not newdiz.get('Open Answer', None): newdiz['Open Answer'] = 1 else: newdiz['Open Answer'] += 1 else: choice = Choice.objects.get( question=ans.question, value=anselt) choiceval = choice.value if not newdiz.get(choiceval, None): newdiz[conditional_escape(choiceval)] = 1 else: newdiz[conditional_escape(choiceval)] += 1 lista_title = conditional_escape(str(i.number) + ") " + i.text) lista.append((lista_title, newdiz, i.number)) for y in newdiz.items(): if y[1]: newdiz_percent[y[0]] = round( float(y[1]) / float(len(subjects)) * 100, 2) lista_percent.append((lista_title, newdiz_percent, i.number)) return TemplateResponse(self.request, self.template_name, locals())
def create_access_account(sender, instance, created, **kwargs): if created: model = _get_model_from_auth_profile_module() model(user=instance).save()
class LoginView(_FormView, CaptchableView): """ Class based view, copied from django.contrib.auth.views.login Displays the login form and handles the login action. """ model = _get_model_from_auth_profile_module() template_name = 'registration/login_as_ul.html' redirect_field_name = REDIRECT_FIELD_NAME ## TODO: figure out how to use success_url redirect_to = getattr(settings, 'LOGIN_REDIRECT_URL', "") current_app = None authentication_form_class = AuthenticationForm formfields_uniqueness = False allow_login_to_authenticated = ALLOW_LOGIN_TO_AUTHENTICATED allow_token = ALLOW_LOGIN_VIA_TOKEN delete_token_after_use = DELETE_TOKEN_AFTER_USE token = None token_field = 'token' model_token_field_name = 'token' after_login_callback = None def setup_attrs(self, **kwargs): self.redirect_to = self.request.REQUEST.get(self.redirect_field_name, self.redirect_to) netloc = urlparse(self.redirect_to)[1] if netloc and netloc != self.request.get_host(): self.redirect_to = getattr(settings, 'LOGIN_REDIRECT_URL', "") super(LoginView, self).setup_attrs(**kwargs) if self.token is None and self.token_field != 'token': self.token = kwargs.get(self.token_field, None) if not self.allow_token: self.token = None def dispatch(self, request, *args, **kwargs): self.request = request return super(LoginView, self).dispatch(request, *args, **kwargs) def get(self, request, *args, **kwargs): if self.request.user.is_authenticated() and \ not self.allow_login_to_authenticated: return HttpResponseRedirect(self.redirect_to) if self.token is not None: user = authenticate(token=self.token) logger.debug("user %s, token: %s", user, self.token) if user is not None: if user.is_active: auth_login(self.request, user) _try_callback(self, 'after_login_callback') else: self.token = None else: self.token = None if self.delete_token_after_use: try: user.get_profile().token = None user.get_profile().save() except: self.token = None if self.token is None: return super(LoginView, self).get(request, *args, **kwargs) else: assert (self.request.user.is_authenticated()) return HttpResponseRedirect(self.redirect_to) def get_initial(self): initial = super(LoginView, self).get_initial() initial.update({self.redirect_field_name: self.redirect_to}) return initial def get_form_class(self): if self.form_class is not None: return super(LoginView, self).get_form_class() additional_fields = SortedDict() # add input hidden for redirection next_field = forms_fields.CharField(widget=forms_widgets.HiddenInput) additional_fields.update({self.redirect_field_name: next_field}) _maybe_add_captcha(self, additional_fields) uniqueness = self.formfields_uniqueness base = self.authentication_form_class return generic_formclass_factory([], fields_uniqueness=uniqueness, bases=[base], sorted_fields=additional_fields) ## POST related mathod def form_valid(self, form): auth_login(self.request, form.get_user()) _try_callback(self, 'after_login_callback') if self.request.session.test_cookie_worked(): self.request.session.delete_test_cookie() if self.model is None: self.model = _get_model_from_auth_profile_module() if self.current_app is None: self.current_app = self.model.__name__.lower() if self.request.user == form.get_user(): try: self.request.user.get_profile() except (self.model.DoesNotExist, AttributeError): self.model(user=self.request.user).save() return HttpResponseRedirect(self.redirect_to) def form_invalid(self, form): self.request.session.set_test_cookie() current_site = get_current_site(self.request) if self.model is None: self.model = _get_model_from_auth_profile_module() if self.current_app is None: self.current_app = self.model.__name__.lower() context = self.get_context_data( **{ 'form': form, self.redirect_field_name: self.redirect_to, 'site': current_site, 'site_name': current_site.name }) return TemplateResponse(self.request, self.template_name, context, current_app=self.current_app)