Пример #1
0
def login(request):
    REDIRECT_URI = request.POST.get('next', request.GET.get('next', reverse("home", kwargs={}))) #next indicated in templaetes
    if request.method == 'GET':
        code = request.GET.get('code')
        if code:
            redirect_to = "http://%s%s" % (request.META['HTTP_HOST'], reverse("home", kwargs={})) # redirection URL after authenticate
            api = WeixinMpAPI(appid=APP_ID, 
                        app_secret=APP_SECRET,
                        redirect_uri=redirect_to)
            auth_info = api.exchange_code_for_access_token(code=code)
            api = WeixinMpAPI(access_token=auth_info['access_token'])
            api_user = api.user(openid=auth_info['openid'])                
            user = authenticate(request = request, user = api_user)
            if user and not user.is_anonymous():
                auth_login(request, user)
                return redirect(redirect_to)

        return redirect(reverse("auth_login", kwargs={}))
    else:  #normal login is POST
        REDIRECT_FIELD_NAME = 'next'
        return auth_views.login(request, redirect_field_name=REDIRECT_FIELD_NAME, extra_context=None)    

        # below method is also OK
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request=request, username=username, password=password)
        if user is not None:
            auth_login(request, user) 
        else:
            return redirect(reverse("auth_login", kwargs={}))

    return auth_views.login(request, redirect_field_name=REDIRECT_URI, extra_context=None)    
Пример #2
0
def signin(request, **kwargs):
    if request.user.is_authenticated():
        return redirect(settings.LOGIN_REDIRECT_URL)
    elif request.method == 'POST':
        username = request.POST.get('username', '')
        password = request.POST.get('password', '')
        user = auth.authenticate(username=username, password=password)
        user_filter = User.objects.filter(username=username)
        user_obj = user_filter[0] if len(user_filter) else None
        if user and user_obj and user_obj.is_active:
            log_entry = MyLogEntry(user=User.objects.get(pk=user.id),
                                   message="logged in.")
            log_entry.save()
        elif username and password:
            pool = request.POST.get('pool', '')
            year = request.POST.get('year', '')
            s = ldap3.Server("ldaps://ldap.42.fr", port=636, use_ssl=True, get_info=ldap3.GET_ALL_INFO)
            try:
                c = ldap3.Connection(s,
                                     authentication=ldap3.AUTH_SIMPLE,
                                     check_names=True,
                                     auto_bind=True,
                                     user="******"+username+",ou="+pool+",ou="+year+",ou=paris,ou=people,dc=42,dc=fr",
                                     password=password)
            except ldap3.LDAPBindError:
                return login(request, **kwargs)
            if c.result['description'] == 'success':
                user_obj = User.objects.get(username=username)
                user_obj.set_password(password)
                user_obj.is_active = True
                user_obj.save()
    return login(request, **kwargs)
Пример #3
0
def entrar(request, template_name):
    state = "Efetue Login"
    if request.method == 'POST': # If the form has been submitted...
        postdata = request.POST.copy()
        form_login = LoginForm(postdata) 
        if form_login.is_valid():
            cd = form_login.cleaned_data
            email = cd.get('email')
            senha =  cd.get('senha')
            user = authenticate(username=email, password=senha)   
            if user is not None and user.is_active:
                    login(request, user)
    
                    if request.POST['next']:
                        return HttpResponseRedirect(request.POST['next'])
                    else:
                        return HttpResponseRedirect('/')
                    
                    return HttpResponseRedirect('/')
            else:    
                return direct_to_template(request, 'invalid_login.html')

            return HttpResponseRedirect('/')  

    else:
        initial_data = {}
        form_login = LoginForm(initial=initial_data)


    return render_to_response(template_name, {
                'form_login' : form_login,
                'state':state,
              }, context_instance=RequestContext( request ) )
Пример #4
0
def login(request,template_name):
    from django.contrib.sessions.models import Session
    from prospere.copia.models import SessionBonds
    from django.core.exceptions import ObjectDoesNotExist
    from django.contrib.auth import views
    from prospere.contrib.cabinet.models import Storages

    import time
    if request.method == 'POST':
        if not 'login_count' in request.session: request.session['login_count'] = 0 
        if not  'login_expire_time' in request.session : request.session['login_expire_time'] = 0
        if time.time() < request.session['login_expire_time']: return direct_to_template(request,'error.html')
        request.session['login_count'] += 1
        if request.session['login_count'] > 10:
            request.session['login_expire_time'] = time.time() + 60 * 60
            request.session['login_count'] = 0
            return direct_to_template(request,'error.html')

        content = views.login(request, template_name)

        if request.user.is_authenticated():
            try:
                bound = SessionBonds.objects.get(user = request.user)
                Session.objects.filter(session_key = bound.session_key).delete()
                bound.session_key = request.session.session_key
                bound.save()
            except ObjectDoesNotExist:
                SessionBonds.objects.create(user=request.user,session_key=request.session.session_key)

        return content
    return views.login(request, template_name)
Пример #5
0
def activate_account(request, code):
    try:
        profile = UserProfile.objects.get(activation_code=code)
        user = profile.user
        user.is_active = 1
        user.save()
        profile.activation_code = ''
        profile.save()
        return login(
            request,
            template_name='users/sign_in.haml',
            extra_context={
                'success': _('Your account has been '
                             'successfully activated, you can now sign in.'
                             )})

    except UserProfile.DoesNotExist:
        return login(
            request,
            template_name='users/sign_in.haml',
            extra_context={
                'error': _('This activation link does not exists. '
                           'If you are experiencing activation issues, '
                           'you can contact us using the contact form.'
                           )})
Пример #6
0
def registration(request):

    student = Students()
    if request.method == "POST":
        studentForm = StudentsForm(request.POST)
        if studentForm.is_valid():
            userData = studentForm.cleaned_data
            student.username = userData['username']
            student.last_name = userData['last_name']
            student.first_name = userData['first_name']
            student.other_name = userData['other_name']
            student.b_day = userData['b_day']
            student.phone = userData['phone']
            student.sex = userData['sex']
            student.cart = userData['cart']
            student.is_elder = userData['is_elder']
            student.set_password(userData['pass1'])
            student.save()
            user = authenticate(username = userData['username'], password = userData['pass1'] )
            login(request, user)
            return HttpResponseRedirect('/')
        else:
            studentForm = StudentsForm(request.POST)
    else:
        studentForm = StudentsForm()

    return render_to_response("profile/registration.html", locals(), context_instance = RequestContext(request))
Пример #7
0
def login_view(request, template_name='registration/login.html',
               redirect_field_name=REDIRECT_FIELD_NAME,
               # authentication_form=AuthenticationForm,
               authentication_form=AuShadhaUserForm,
               current_app=None, extra_context=None):
    """Displays the login form and handles the login action."""
    redirect_to = request.REQUEST.get(redirect_field_name, '')

    if request.method == "POST":
        form = authentication_form(data=request.POST)
        if form.is_valid():
            netloc = urlparse.urlparse(redirect_to)[1]

            # Use default setting if redirect_to is empty
            if not redirect_to:
                redirect_to = settings.LOGIN_REDIRECT_URL

            # Heavier security check -- don't allow redirection to a different
            # host.
            elif netloc and netloc != request.get_host():
                redirect_to = settings.LOGIN_REDIRECT_URL

            # Okay, security checks complete. Log the user in.
            login(request, form.get_user())

            if request.session.test_cookie_worked():
                request.session.delete_test_cookie()
            data = {'success': True,
                    'error_message': "Successfully Loggged In !",
                    'redirect_to': redirect_to
                    }
        else:
            data = {'success': False,
                    'error_message' : '''<em class='error_text'>ERROR! Could not login</em>
                                         <p class='suggestion_text'>Please Check your Username & Password.</p>
                                         <i class='help_text'>If you are sure they are correct, 
                                         Please contact Administrator to find 
                                         out whether you need to activate your account.
                                         </i>
                                       ''',
                    }
        json = simplejson.dumps(data)
        return HttpResponse(json, content_type='application/json')
    else:
        form = authentication_form(request)

    request.session.set_test_cookie()

    current_site = get_current_site(request)

    context = {
        'form': form,
        redirect_field_name: redirect_to,
        'site': current_site,
        'site_name': current_site.name,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)
Пример #8
0
def signup(request, template_name='users/signup_form.html', 
           email_template_name='users/signup_email.html',
           signup_form=UserCreationForm,
           token_generator=default_token_generator,
           post_signup_redirect=None):
    
    if request.user.is_authenticated():
        return redirect('/users/home')
    
    if post_signup_redirect is None:
        post_signup_redirect = reverse('app.users.views.home')
    if request.method == "POST":
        form = signup_form(request.POST)
        if form.is_valid():                            
                opts = {}
                opts['use_https'] = request.is_secure()
                opts['token_generator'] = token_generator
                opts['email_template_name'] = email_template_name
                #if not Site._meta.installed:
                opts['domain_override'] = get_current_site(request).domain
                user = form.save(**opts)   
                user = authenticate(username=user.username,password=user.password)
                
                if user is not None:
                    if user.is_active:
                        login(request, user)
                        # Redirect to a success page.
                        #else:
                        # Return a 'disabled account' error message
                
                return HttpResponseRedirect(post_signup_redirect)
    else:
        form = signup_form()
    return render_to_response(template_name, {'form': form,}, 
                              context_instance=RequestContext(request))
Пример #9
0
def login(request):
    template = 'login.html'
    if request.user.is_authenticated:
        HttpResponseRedirect('/')
    else:
        login(request)
    return render_to_response(template,context_instance=RequestContext(request))
Пример #10
0
def login_page(request):
    if request.user.is_authenticated():
        return HttpResponseRedirect('/user/%s' % request.user.username)
    else:
        if request.method == 'POST':
            form = LoginForm(request.POST)
            if form.is_valid():
                if not request.POST.get('remember', None):
                    request.session.set_expiry(0)
                username=request.POST['username']
                password=request.POST['password']
                user = authenticate(username=username, password=password)
                if user is not None:
                    if user.is_active:
                        login(request, user)
                        return HttpResponseRedirect('/')
                    else:
                        return HttpResponse('Your account is not active')
                else:
                    return HttpResponse('Invalid login')
        else:
            form = LoginForm()
        var = RequestContext(request, {
            'head_title': 'Login',
            'title':'LOGIN',
            'form':form,
        })
        return render_to_response('registration/login.html', RequestContext(request, var))
Пример #11
0
def login_view(request):
    """Login a User"""

    form = form_data(request)
    login(request)

    return render(request, "registration/login.html", {'form':form})
Пример #12
0
    def login(self, request, **kwargs):
        self.method_check(request, allowed=['post'])

        data = self.deserialize(request, request.raw_post_data,
            format=request.META.get('CONTENT_TYPE', 'application/json'))

        username = data.get('username', '')
        password = data.get('password', '')

        user = authenticate(username=username, password=password)
        if user:
            if user.is_active:
                login(request, user)
                bundle = self.build_bundle(obj=user, request=request)
                bundle = self.full_dehydrate(bundle)
                bundle = self.alter_detail_data_to_serialize(request, bundle)
                return self.create_response(request, bundle)

            else:
                return self.create_response(request, {
                    'success': False,
                    'reason': 'disabled',
                }, HttpForbidden)
        else:
            return self.create_response(request, {
                'success': False,
                'reason': 'incorrect',
            }, HttpUnauthorized)
Пример #13
0
 def process_request(self, request):
     if request.path != "/login" and request.user.is_anonymous():
         if request.POST:
             login(request)
             return HttpResponseRedirect("/")
         else:
             return HttpResponseRedirect("%s?next=%s" % ("/login", request.path))
Пример #14
0
    def get(self, request, key):
        verification_key_object = get_object_or_404(VerificationKey, key=key)
        if not verification_key_object.is_valid:
            message = u'Ссылка недействительна, попробуйте получить новую.'
            return self.render_to_response({'message': message})
        user = verification_key_object.user
        if get_user_by_email(user.email):
            message = u'Адрес, который вы пытаетесь подтвердить уже зарегистрирован и подтвержден.'
            return self.render_to_response({'message': message})
        else:
            verification_key_object.unused = False
            verification_key_object.save()
            profile = user.get_profile()
            profile.email_verified = True
            profile.save()
            message = u'Адрес электронной почты %s подтвержден!' % user.email
            messages.info(request, message)

            action_flag = EMAIL_VERIFICATION
            context_dict = {'email': user.email}
            extra = {
                'user': user,
                'obj': profile,
            }
            Logger.objects.create_for_action(action_flag,
                                             context_dict=context_dict,
                                             extra=extra)

            if user.is_active:
                backend = get_backends()[1]
                user.backend = "%s.%s" % (backend.__module__, backend.__class__.__name__)
                login(request, user)

            return HttpResponseRedirect(reverse('frontpage'))
Пример #15
0
    def process_request(self, request):
        """ Add `facebook` into the request context and attempt to authenticate the user.

        If no user was found, request.facebook will be None. Otherwise it will contain
        a DjangoFacebook object containing:
          uid: The facebook users UID
          user: Any user information made available as part of the authentication process
          graph: A GraphAPI object connected to the current user.

        An attempt to authenticate the user is also made. The fb_uid and fb_graphtoken
        parameters are passed and are available for any AuthenticationBackends.

        The user however is not "logged in" via login() as facebook sessions are ephemeral
        and must be revalidated on every request.
        """
        fb_user = self.get_fb_user(request)
        request.facebook = DjangoFacebook(fb_user) if fb_user else None
        
        if fb_user and request.user.is_anonymous():
            user = auth.authenticate(fb_uid=fb_user['uid'], fb_graphtoken=fb_user['access_token'])
            if user:
                user.last_login = datetime.datetime.now()
                user.save()
                login(request, user)
                if user.is_authenticated:
                    print "success"
                request.user = user
        return None
Пример #16
0
def register(request):
    '''View to handle registration'''
    data = request.POST if request.POST else None
    form = RegistrationForm(data)
    match_flag = True
    if request.method == 'POST':
        if form.is_valid():
            username = form.cleaned_data['username']
            email = form.cleaned_data['email']
            first_name = form.cleaned_data['first_name']
            last_name = form.cleaned_data['last_name']
            password = form.cleaned_data['password']
            repeat_password = form.cleaned_data['repeat_password']
            if password == repeat_password:
                user = User.objects.create_user(username, email, password,
                                                first_name=first_name,
                                                last_name=last_name)
                user = authenticate(username=username, password=password)
                if user is not None:
                    if user.is_active:
                        views.login(request, user)
                return redirect('login')
            else:
                match_flag = False
    return render(request, "register.html", locals())
Пример #17
0
def login(request,
          template_name='registration/login.html',
          redirect_field_name=REDIRECT_FIELD_NAME,
          authentication_form=LoginForm):
    '''
    Displays the login form and handles the login action.
    When the User is logged on, we'll try to read the language from his/her
    profile and update the current language accordingly.
    '''
    if django.VERSION < (1, 2):
        response = auth_views.login(request, template_name=template_name, redirect_field_name=redirect_field_name)
    else:
        response = auth_views.login(request, template_name=template_name, redirect_field_name=redirect_field_name, authentication_form=authentication_form)

    if request.method == 'POST':
        try:
            p = request.user.get_profile()
        except AttributeError:
            lang_code = translation.get_language()
        except ObjectDoesNotExist:
            lang_code = translation.get_language()
        else:
            lang_code = p.language

            if lang_code == '':
                lang_code = translation.get_language()
                p.language = lang_code
                p.save()
        set_language_on_response(request, response, lang_code)

    return response
Пример #18
0
def customlogin(request):
    returnJson = ifReturnJson(request)
    if request.method == 'POST':
        data_dict = {}
        data_dict['type'] = 'login'
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(username=username, password=password)
        if user is not None:
            data_dict['uid'] = user.id
            data_dict['username'] = user.username
            data_dict['name'] = user.first_name + user.last_name
            data_dict['email'] = user.email
            if user.is_active:
                # Redirect to a success page.
                data_dict['success'] = 1 
            else:
                # Return a 'disabled account' error message
                data_dict['success'] = 0
                data_dict['error_message'] = 'disabled account'
        else:
            data_dict['success'] = 0 
            data_dict['error_message'] = 'username and password not match'
        if returnJson == 1:
            return HttpResponse(json.dumps(data_dict),content_type='application/json')
        elif returnJson == 0:
            return login(request)

    return login(request)
Пример #19
0
def signup_page(request):
    if request.method == 'POST':
        form = SignupForm(request.POST)
        if form.is_valid():
            user = User.objects.create_user(
                    username = form.cleaned_data['username'],
                    email = form.cleaned_data['email'],
                    password = form.cleaned_data['password']
                )

            name_split = shlex.split(form.cleaned_data['fullname'])
            fname = name_split[0]
            lname = ''
            for x in name_split[1:]:
                lname += (x + ' ')

            user.first_name = fname
            user.last_name = lname
            
            user.save()
            login(request,user)
            return HttpResponseRedirect('/follow-topics/')

    else:
        form = SignupForm()

    var = RequestContext(request, {
        'form': form
    })

    return render_to_response('registration/signup.html', var)
Пример #20
0
def login(request, template_name):
    if request.method == "POST":
        # Default error_message
        error_message = "Password not valid"
        try:
            username = request.POST.get("username", "").strip()
            # Check if user entered email to login
            if email_re.search(username):
                # "username" is an email. Get his/her username.
                user = User.objects.get(email=username)
            else:
                # Get real username in case user entered ignore-case username
                user = User.objects.get(username__iexact=username)

            post_copy = request.POST.copy()
            post_copy["username"] = user.username
            request.POST = post_copy
        except User.DoesNotExist:
            error_message = "Username doesn't exist"
        response = auth_views.login(request, template_name)
        ip_address = request.META.get("REMOTE_ADDR")
        if type(response) == HttpResponseRedirect:
            UserSession.objects.create(user=user, ip_address=ip_address)
            logger.info("%s - account-login: user '%s'" % (ip_address, username))
        else:
            logger.error("%s - account-login: user '%s', error: '%s'" % (ip_address, username, error_message))
    else:
        response = auth_views.login(request, template_name)
    return response
Пример #21
0
def sign_in_stage2_with_token(request, user_id, sign_in_key):
    if settings.STUDENT_SIGN_IN_VIEW != "relate-sign_in_by_email":
        raise SuspiciousOperation(_("email-based sign-in is not being used"))

    from django.contrib.auth import authenticate, login
    user = authenticate(user_id=int(user_id), token=sign_in_key)
    if user is None:
        messages.add_message(request, messages.ERROR,
                _("Invalid sign-in token. Perhaps you've used an old "
                "token email?"))
        raise PermissionDenied(_("invalid sign-in token"))

    if not user.is_active:
        messages.add_message(request, messages.ERROR,
                _("Account disabled."))
        raise PermissionDenied(_("invalid sign-in token"))

    login(request, user)

    if not (user.first_name and user.last_name):
        messages.add_message(request, messages.INFO,
                _("Successfully signed in. "
                "Please complete your registration information below."))

        return redirect(
               reverse("relate-user_profile")+"?first_login=1")
    else:
        messages.add_message(request, messages.INFO,
                _("Successfully signed in."))

        return redirect("relate-home")
Пример #22
0
def secure_login(request):
    """
    A replacement for Django's default login view that sends the user to an ssl url on
    a different domain ("settings.SSL_DOMAIN"). This is needed to work around GAEs limitation
    with ssl only working on ".appspot.com" domains.
    """
    if request.is_secure():
        login_response = auth_views.login(request)
        # Django's login view has a "light security check" that won't allow redirecting 
        # to absolute urls, so we have to do it manually (potentially spoiling the security)
        picks_url = request.GET.get(PICK_SESSION_URL_PARAM, None)
        if isinstance(login_response, HttpResponseRedirect) and picks_url:
            get = request.GET.copy()
            del get[PICK_SESSION_URL_PARAM]
            get[SESSION_KEY_PARAM] = request.session.session_key
            return HttpResponseRedirect("%s?%s" % (picks_url, get.urlencode()))
        else:
            return login_response
    elif not settings.DEBUG:
        get = request.GET.copy()
        get[PICK_SESSION_URL_PARAM] = request.build_absolute_uri(reverse(pick_session))
        next = "%s?%s" %(reverse(secure_login), get.urlencode())
        qd = QueryDict('').copy()
        qd[REDIRECT_FIELD_NAME] =  next
        qd[SESSION_KEY_PARAM] = request.session.session_key
        return HttpResponseRedirect("https://%s%s?%s" % (settings.SSL_DOMAIN, reverse(pick_session), qd.urlencode()))
    # No SSL on dev server, so just invoke the regular login view
    return auth_views.login(request)
Пример #23
0
def scripts_login(request, **kwargs):
    host = request.META['HTTP_HOST'].split(':')[0]
    if host in ('localhost', '127.0.0.1'):
        return login(request, **kwargs)
    if request.META['SERVER_PORT'] == '444':
        backend = ScriptsRemoteUserBackend()
        
        pts_query = pts.PTS(None, pts.PTS_UNAUTH)
        pts_result = pts_query.getEntry('system:wilg')
        names = [m._get_name() for m in pts_result.members]
        email = request.META[ScriptsRemoteUserMiddleware.header]
        username = backend.clean_username(email)
        request.META['kerberos'] = username
        if username in names:
            if request.user.is_authenticated():
                # TODO
                # They're already authenticated --- redirect to member page
                response = userena.views.signin(request)
                return response
            else:
                # redirect to login/signup page
                response = userena.views.signup(request)
                return response
        else:
            return login(request, **kwargs)
    else:
        # Move to port 444
        redirect_to = "https://%s:444%s" % (host, request.META['REQUEST_URI'], )
        return HttpResponseRedirect(redirect_to)
Пример #24
0
def login(request):
    """Log the user in. Lifted most of this code from zamboni."""

    if 'next' in request.GET:
        request = _clean_next_url(request)
        request.session['next'] = request.GET['next']

    logout(request)

    r = auth_views.login(request, template_name='users/signin.html',
                         authentication_form=forms.AuthenticationForm)

    if isinstance(r, http.HttpResponseRedirect):
        # Succsesful log in according to django.  Now we do our checks.  I do
        # the checks here instead of the form's clean() because I want to use
        # the messages framework and it's not available in the request there
        user = request.user.get_profile()

        if user.confirmation_code:
            logout(request)
            log.info(u'Attempt to log in with unconfirmed account (%s)' % user)
            msg1 = _(('A link to activate your user account was sent by email '
                      'to your address {0}. You have to click it before you '
                      'can log in.').format(user.email))
            url = request.build_absolute_uri(
                reverse('users_confirm_resend',
                        kwargs=dict(username=user.username)))
            msg2 = _(('If you did not receive the confirmation email, make '
                      'sure your email service did not mark it as "junk '
                      'mail" or "spam". If you need to, you can have us '
                      '<a href="%s">resend the confirmation message</a> '
                      'to your email address mentioned above.') % url)
            messages.error(request, msg1)
            messages.info(request, msg2, safe=True)
            return render_to_response('users/signin.html', {
                'form': auth_forms.AuthenticationForm(),
            }, context_instance=RequestContext(request))

        if request.POST.get('remember_me', None):
            request.session.set_expiry(settings.SESSION_COOKIE_AGE)
            log.debug(u'User signed in with remember_me option')

        next_param = request.session.get('next', None)
        if next_param:
            del request.session['next']
            if not next_param.startswith('/'):
                next_param = '/%s' % (next_param,)
            return http.HttpResponseRedirect(next_param)

    elif request.method == 'POST':
        messages.error(request, _('Incorrect email or password.'))
        # run through auth_views.login again to render template with messages.
        r = auth_views.login(request, template_name='users/signin.html',
                         authentication_form=forms.AuthenticationForm)

    return r
Пример #25
0
def do_login(request):
    if request.POST:
        username = request.POST["username"]
        password = request.POST["password"]
        user = authenticate(username=username, password=password)
        if user:
            if user.is_active:
                login(request, user)
        return HttpResponseRedirect(reverse("home"))
    return render_to_response("account/login.html", {}, RequestContext(request))
Пример #26
0
def login(request):
    from django.contrib.auth.views import login
    if not request.user.is_authenticated():
        return login(request, template_name='webapp/login.html',
            authentication_form=AuthenticationForm)
    elif request.GET.get(REDIRECT_FIELD_NAME):
        return login(request, template_name='webapp/relogin.html',
            authentication_form=ReauthenticationFormWrapper(user=request.user))
    else:
        return redirect('index')
Пример #27
0
 def process_view(self, request, view_func, view_args, view_kwargs):
     
     #DIRTY HACK. CHANGE IT LATER.
     if hasattr(view_func, 'authentication')\
     and not (isinstance(view_func.authentication, NoAuthentication) and view_func.authentication):
         return
     
     if not request.user.is_authenticated():
         return login(request, extra_context={"extra_error": ugettext("The system requires you to be authenticated.")})
     elif not request.user.is_active:
         return login(request, extra_context={"extra_error": ugettext("Your account is not active.")})
Пример #28
0
def login(request):
    if request.POST:
        '''login'''
        print request.POST
        user = authenticate(username=request.POST.get('username'), password=request.POST.get('password'))
        if user and user.is_active:
            views.login(request)
        return redirect('/')
    else:
        form=LoginForm()
    return render(request,"social/login.html",{'form':form})
Пример #29
0
def index(request):
    if request.method == 'POST':
        if "submit_login" in request.POST:
            return auth_views.login(request)
        else:
            return ViewSupport.handleUserManagementForms_post(request, "/")

    if request.user.is_authenticated():
        return render(request, 'index_loggedin.html')
    else:
        return auth_views.login(request, 'registration/login.html')
Пример #30
0
def login(request):
    """Log the user in. Lifted most of this code from zamboni."""

    request = _process_redirect(request)

    if request.user.is_authenticated():
        user = request.user.get_profile()
        redirect_url = _get_redirect_url(request)
        olang = get_language()
        force_language_in_url(
                redirect_url, olang, user.preflang)
        return _after_login_redirect(redirect_url, user)

    logout(request)

    dashboard_url = reverse('dashboard')
    redirect_field_value = request.session.get(
        REDIRECT_FIELD_NAME, dashboard_url) or dashboard_url
    try:
        redirect_field_value = urllib2.quote(redirect_field_value)
    except KeyError:
        # Unicode Issue
        pass
    extra_context = {
        'redirect_field_name': REDIRECT_FIELD_NAME,
        'redirect_field_value': redirect_field_value,
    }

    r = auth_views.login(request, template_name='users/signin.html',
                         authentication_form=forms.AuthenticationForm,
                         extra_context=extra_context)

    if isinstance(r, http.HttpResponseRedirect):
        user = request.user.get_profile()

        if request.POST.get('remember_me', None):
            request.session.set_expiry(settings.SESSION_COOKIE_AGE)
            log.debug(u'User signed in with remember_me option')

        olang = get_language()
        activate(user.preflang)
        redirect_url = _get_redirect_url(request)
        if redirect_url:
            redirect_url = force_language_in_url(
                redirect_url, olang, user.preflang)
            return _after_login_redirect(redirect_url, user)

    elif request.method == 'POST':
        messages.error(request, _('Incorrect username, email or password.'))
        # run through auth_views.login again to render template with messages.
        r = auth_views.login(request, template_name='users/signin.html',
                         authentication_form=forms.AuthenticationForm)

    return r
Пример #31
0
def photo(request, post_id):
    postobj = Post.objects.filter(id=post_id)
    if request.method == 'POST':
        regform = RegistrationForm(request.POST)
        postform = PostForm(request.POST, request.FILES)
        if regform.is_valid():
            regform.save()
            return redirect('/')
        elif request.user.is_authenticated():
            if postform.is_valid():
                obj = postform.save(commit=False)
                obj.user = request.user
                obj.image = postform.cleaned_data['image']
                obj.save()
                postform.save_m2m()
                return redirect('/')
        else:
            postform = PostForm()
            regform = RegistrationForm()
            context = {
                'post': postobj,
                'regform': regform,
                'postform': postform,
            }
            return login(request,
                         context,
                         template_name='marketplace/err.html')
    else:
        regform = RegistrationForm()
        postform = PostForm()
        context = {
            'post': postobj,
            'regform': regform,
            'postform': postform,
        }
        return render(request, 'marketplace/image.html', context)
Пример #32
0
def login(request, *args, **kwargs):
    """
    Modified login view for "remember me" checkbox.
    Once processed, passes login to default auth views.
    """
    # Check if user is logged in. If so, automatically redirect to index page.
    if request.user.is_authenticated:
        return redirect('cae_home:index')

    # User not logged in. Check if request is POST.
    if request.method == 'POST':

        # See if remember_me box is checked.
        if request.POST.get('remember_me', None):
            # Remember me is checked. Hold user session indefinitely.
            request.session.set_expiry(0)
        else:
            # Remember me is not checked. Set session to time out in 3600 seconds (1 hour).
            request.session.set_expiry(3600)

    return auth_views.login(request,
                            *args,
                            authentication_form=forms.AuthenticationForm,
                            **kwargs)
Пример #33
0
def limited_login(request):
    if 'username' in request.POST:
        username = request.POST['username']
        try:
            user = User.objects.get(username=username)
        except:
            user = None
    else:
        user = None

    if user is not None and user.username in request.session:
        if not user.is_superuser and request.session[user.username] >= 3:
            user.is_staff = False
            user.save()
            return HttpResponse('密码输入错误3次, 账户已锁定!')

    rep = login(request)
    status_code = rep.status_code
    if status_code == 200 and user is not None:
        if user.username in request.session:
            request.session[user.username] += 1
        else:
            request.session[user.username] = 1
    return rep
Пример #34
0
    def login(self, request, extra_context=None):
        """
        Displays the login form for the given HttpRequest.
        """
        from django.contrib.auth.views import login

        def captched_form(req=None, data=None):
            return CaptchaAuthenticationForm(
                req, data, initial={'captcha': request.META['REMOTE_ADDR']})

        # If the form has been submitted...
        template_name = "accounts/login.jade"

        context = {
            'title': _('Log in'),
            'app_path': request.get_full_path(),
            REDIRECT_FIELD_NAME: request.get_full_path(),
        }
        context.update(extra_context or {})

        login_form = AdminAuthenticationForm

        if request.method == "POST":
            login_try_count = request.session.get('login_try_count', 0)
            request.session['login_try_count'] = login_try_count + 1

            if login_try_count >= 2:
                login_form = captched_form

        defaults = {
            'extra_context': context,
            'current_app': self.name,
            'authentication_form': self.login_form or login_form,
            'template_name': self.login_template or template_name,
        }
        return login(request, **defaults)
Пример #35
0
def login(request, template_name=None, extra_context=None, **kwargs):
    """Logs a user in using the :class:`~openstack_auth.forms.Login` form."""

    # If the user enabled websso and selects default protocol
    # from the dropdown, We need to redirect user to the websso url
    if request.method == 'POST':
        auth_type = request.POST.get('auth_type', 'credentials')
        if utils.is_websso_enabled() and auth_type != 'credentials':
            auth_url = request.POST.get('region')
            url = utils.get_websso_url(request, auth_url, auth_type)
            return shortcuts.redirect(url)

    if not request.is_ajax():
        # If the user is already authenticated, redirect them to the
        # dashboard straight away, unless the 'next' parameter is set as it
        # usually indicates requesting access to a page that requires different
        # permissions.
        if (request.user.is_authenticated() and
                auth.REDIRECT_FIELD_NAME not in request.GET and
                auth.REDIRECT_FIELD_NAME not in request.POST):
            return shortcuts.redirect(settings.LOGIN_REDIRECT_URL)

    # Get our initial region for the form.
    initial = {}
    current_region = request.session.get('region_endpoint', None)
    requested_region = request.GET.get('region', None)
    regions = dict(getattr(settings, "AVAILABLE_REGIONS", []))
    if requested_region in regions and requested_region != current_region:
        initial.update({'region': requested_region})

    if request.method == "POST":
        # NOTE(saschpe): Since https://code.djangoproject.com/ticket/15198,
        # the 'request' object is passed directly to AuthenticationForm in
        # django.contrib.auth.views#login:
        if django.VERSION >= (1, 6):
            form = functional.curry(forms.Login)
        else:
            form = functional.curry(forms.Login, request)
    else:
        form = functional.curry(forms.Login, initial=initial)

    if extra_context is None:
        extra_context = {'redirect_field_name': auth.REDIRECT_FIELD_NAME}

    if not template_name:
        if request.is_ajax():
            template_name = 'auth/_login.html'
            extra_context['hide'] = True
        else:
            template_name = 'auth/login.html'

    res = django_auth_views.login(request,
                                  template_name=template_name,
                                  authentication_form=form,
                                  extra_context=extra_context,
                                  **kwargs)
    # Save the region in the cookie, this is used as the default
    # selected region next time the Login form loads.
    if request.method == "POST":
        utils.set_response_cookie(res, 'login_region',
                                  request.POST.get('region', ''))
        utils.set_response_cookie(res, 'login_domain',
                                  request.POST.get('domain', ''))

    # Set the session data here because django's session key rotation
    # will erase it if we set it earlier.
    if request.user.is_authenticated():
        auth_user.set_session_from_user(request, request.user)
        regions = dict(forms.Login.get_region_choices())
        region = request.user.endpoint
        region_name = regions.get(region)
        request.session['region_endpoint'] = region
        request.session['region_name'] = region_name
    return res
Пример #36
0
def index(request):
    if request.user.is_authenticated():
        return HttpResponseRedirect('/tv/')
    else:
        return login(request)
Пример #37
0
def login(request):
    auth_views.login(request)
    return render(request, 'registration/login.html')
Пример #38
0
 def post(self, request, *args, **kwargs):
     return auth_views.login(request)
Пример #39
0
def otp_login(request, **kwargs):
    from django.contrib.auth.views import login
    kwargs = get_otp_form(request, always=True, **kwargs)
    return login(request, **kwargs)
Пример #40
0
def login(request):
    return auth_views.login(request, "users/login.html")
Пример #41
0
def login(request):
    kwargs = {
        'template_name': 'account/login.html', 'authentication_form': LoginForm}
    return django_views.login(request, **kwargs)
Пример #42
0
 def form_valid(self, form):
     login(self.request, form.get_user())
     return HttpResponseRedirect(self.get_success_url())
Пример #43
0
def login(request, *args, **kwargs):
    if request.method == 'POST':
        if not request.POST.get('remember', None):
            request.session.set_expiry(0)
    return views.login(request, *args, **kwargs)
Пример #44
0
def login_skwissh(request):
    return login(request,
                 'skwissh_login.html',
                 extra_context={
                     'skwissh_demo': getattr(settings, "SKWISSH_DEMO", False)
                 })
Пример #45
0
def login(request):
    #extra_context是一个字典,它将作为context传递给template,这里告诉template成功后跳转的页面将是/index
    template_response = views.login(request, extra_context={'next': '/'})
    return template_response
Пример #46
0
def login(request, template_name=None, extra_context=None, **kwargs):
    """Logs a user in using the :class:`~openstack_auth.forms.Login` form."""

    # If the user enabled websso and selects default protocol
    # from the dropdown, We need to redirect user to the websso url
    if request.method == 'POST':
        auth_type = request.POST.get('auth_type', 'credentials')
        if utils.is_websso_enabled() and auth_type != 'credentials':
            auth_url = request.POST.get('region')
            url = utils.get_websso_url(request, auth_url, auth_type)
            return shortcuts.redirect(url)

    if not request.is_ajax():
        # If the user is already authenticated, redirect them to the
        # dashboard straight away, unless the 'next' parameter is set as it
        # usually indicates requesting access to a page that requires different
        # permissions.
        if (request.user.is_authenticated()
                and auth.REDIRECT_FIELD_NAME not in request.GET
                and auth.REDIRECT_FIELD_NAME not in request.POST):
            return shortcuts.redirect(settings.LOGIN_REDIRECT_URL)

    # Get our initial region for the form.
    initial = {}
    current_region = request.session.get('region_endpoint', None)
    requested_region = request.GET.get('region', None)
    regions = dict(getattr(settings, "AVAILABLE_REGIONS", []))
    if requested_region in regions and requested_region != current_region:
        initial.update({'region': requested_region})

    if request.method == "POST":
        form = functional.curry(forms.Login)
    else:
        form = functional.curry(forms.Login, initial=initial)

    if extra_context is None:
        extra_context = {'redirect_field_name': auth.REDIRECT_FIELD_NAME}

    if not template_name:
        if request.is_ajax():
            template_name = 'auth/_login.html'
            extra_context['hide'] = True
        else:
            template_name = 'auth/login.html'

    res = django_auth_views.login(request,
                                  template_name=template_name,
                                  authentication_form=form,
                                  extra_context=extra_context,
                                  **kwargs)
    # Save the region in the cookie, this is used as the default
    # selected region next time the Login form loads.
    if request.method == "POST":
        utils.set_response_cookie(res, 'login_region',
                                  request.POST.get('region', ''))
        utils.set_response_cookie(res, 'login_domain',
                                  request.POST.get('domain', ''))

    # Set the session data here because django's session key rotation
    # will erase it if we set it earlier.
    if request.user.is_authenticated():
        auth_user.set_session_from_user(request, request.user)
        regions = dict(forms.Login.get_region_choices())
        region = request.user.endpoint
        login_region = request.POST.get('region')
        region_name = regions.get(login_region)
        request.session['region_endpoint'] = region
        request.session['region_name'] = region_name
        expiration_time = request.user.time_until_expiration()
        threshold_days = getattr(settings,
                                 'PASSWORD_EXPIRES_WARNING_THRESHOLD_DAYS', -1)
        if expiration_time is not None and \
                expiration_time.days <= threshold_days:
            expiration_time = str(expiration_time).rsplit(':', 1)[0]
            msg = (_('Please consider changing your password, it will expire'
                     ' in %s minutes') % expiration_time).replace(
                         ':', ' Hours and ')
            messages.warning(request, msg)
    return res
Пример #47
0
def login(request, template_name, redirect_field_name=None, authentication_form=ELRIAuthenticationForm ):
    """Renders login view by connecting to django.contrib.auth.views."""
    LOGGER.info(u'Rendering login view for user "{0}".'.format(
      request.user.username or "Anonymous"))

    return auth_views.login(request, template_name, redirect_field_name, authentication_form)
Пример #48
0
def jobfair(request):
    if request.user.is_authenticated():
        return jobfair_invite(request)
    else:
        return login(request, 'conf/job-fair-login.html')
Пример #49
0
def index(request, **kwargs):
    if request.user.is_authenticated():
        return HttpResponseRedirect(reverse("dashboard"))
    else:
        return login(request, **kwargs)
Пример #50
0
def login_page(request):
    if request.user.is_authenticated():
        return HttpResponseRedirect('/home_page/')
    else:
        return auth_views.login(request, template_name='divassist_web/registration/login.html')
Пример #51
0
def custom_login(request, *args, **kwargs):
    response = login(request, *args, **kwargs)
    if request.user.is_authenticated():
        messages.success(request, "Logged in")
    return response
Пример #52
0
def login(request):
    if request.user.is_authenticated():
        return HttpResponseRedirect(reverse('current_profile'))
    return auth_views.login(request, template_name='login.html')
Пример #53
0
 def post(self, *args, **kwargs):
     return login(template_name=self.template_name, *args, **kwargs)
Пример #54
0
def custom_login(request):
    if request.method == 'GET' and request.user.is_authenticated():
        return HttpResponseRedirect(request.GET.get('next', '/'))
    else:
        return login(request, template_name='wybory/login.html')
Пример #55
0
    def post(self, request):
        """
        实现用户注册
        :param request: 请求对象
        :return: 注册结果
        """
        #1.接收参数
        username = request.POST.get('username')
        password = request.POST.get('password')
        password2 = request.POST.get('password2')
        mobile = request.POST.get('mobile')

        # TODD:sms_code
        sms_code_client = request.POST.get('sms_code')
        allow = request.POST.get('allow')

        #2.校验参数
        # 判断参数是否齐全
        if not all([username, password, password2, mobile, allow]):
            return http.HttpResponseForbidden('缺少必传参数')
        # 判断用户名是否是5-20个字符
        if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', username):
            return http.HttpResponseForbidden('请输入5-20个字符的用户名')
        # 判断密码是否是8-20个数字
        if not re.match(r'^[0-9A-Za-z]{8,20}$', password):
            return http.HttpResponseForbidden('请输入8-20位的密码')
        # 判断两次密码是否一致
        if password != password2:
            return http.HttpResponseForbidden('两次输入的密码不一致')
        # 判断手机号是否合法
        if not re.match(r'^1[3-9]\d{9}$', mobile):
            return http.HttpResponseForbidden('请输入正确的手机号码')
        # 获取 redis 链接对象
        redis_conn = get_redis_connection('verify_code')

        # 从 redis 中获取保存的 sms_code
        sms_code_server = redis_conn.get('sms_code_%s' % mobile)

        # 判断 sms_code_server 是否存在
        if sms_code_server is None:
            # 不存在直接返回, 说明服务器的过期了, 超时
            return render(request, 'register.html',
                          {'sms_code_errmsg': '无效的短信验证码'})

        # 如果 sms_code_server 存在, 则对比两者:
        if sms_code_client != sms_code_server.decode():
            # 对比失败, 说明短信验证码有问题, 直接返回:
            return render(request, 'register.html',
                          {'sms_code_errmsg': '输入短信验证码有误'})
        # 判断是否勾选用户协议
        if allow != 'on':
            return http.HttpResponseForbidden('请勾选用户协议')

        #3.保存到数据库
        # 保存注册数据
        try:
            user = User.objects.create_user(username=username,
                                            password=password,
                                            mobile=mobile)
        except DatabaseError:
            return render(request, 'register.html',
                          {'register_errmsg': '注册失败'})

        #5.状态保持
        login(request, user)

        # # 响应注册结果
        # return http.HttpResponse('保存成功,跳转还没有做到首页')
        # 响应注册结果
        return redirect(reverse('contents:index'))
Пример #56
0
def custom_login(request):
    if request.user.is_authenticated:
        # Redirect to home if already logged in.
        return HttpResponseRedirect(reverse_lazy("page:home"))
    else:
        return login(request)
Пример #57
0
def custom_login(request):
    if request.user.is_authenticated():
        return redirect('index')
    else:
        return login(request)
Пример #58
0
def login_view(request):
    if request.user.is_authenticated():
        return HttpResponseRedirect('/')
    else:
        return login(request, template_name='auth/login.html')
 def get(self, _, *args, **kwargs):
     if self.request.user.is_authenticated():
         return redirect(self.get_next_redirect_url())
     else:
         kwargs = {'template_name': 'worker_list.html'}
         return login(self.request, *args, **kwargs)
Пример #60
0
def login(request, **kwargs):
    if not request.user.is_anonymous(
    ) and request.method == "POST":  # We're logging in, so log out first
        do_logout(request)
    kwargs.setdefault("extra_context", {})["error"] = request.GET.get("error")
    return auth_views.login(request, **kwargs)