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)
