Example #1
0
def site_authenticate(request):
	scope = request.GET['scope']
	code = request.GET['code']

	connection = httplib.HTTPSConnection('api.twitch.tv', timeout=5)
	connection.request('POST', 'https://api.twitch.tv/kraken/oauth2/token', 'client_id=%s&client_secret=%s&grant_type=authorization_code&redirect_uri=%s&code=%s' % (settings.TWITCH_CLIENT_ID, settings.TWITCH_CLIENT_SECRET, settings.TWITCH_REDIRECT_URL, code))
	response = connection.getresponse()
	if response.status != 200:
		# XXX: proper error message
		raise RuntimeError("calling kraken/oauth2/token")

	body = json.loads(response.read())
	access_token = body['access_token']

	connection.request('GET', 'https://api.twitch.tv/kraken/user?oauth_token=%s' % access_token)
	response = connection.getresponse()
	if response.status != 200:
		# XXX: proper error message
		raise RuntimeError("calling kraken/user")

	twitch_user = json.loads(response.read())
	# keys: bio, display_name, name, created_at, updated_at, partnered, logo, _id, email

	twitch_username = twitch_user['name']

	try:
		user = User.objects.get(username=twitch_username)
	except User.DoesNotExist:
		user = User.objects.create_user(twitch_username, email=twitch_user['email'], password=dummy_password)

	user = authenticate(username=twitch_username, password=dummy_password)
	login(request, user)

	return HttpResponseRedirect('/')
Example #2
0
def login_view(request, message='', username="", password="", template='user/login.html', modal=False):
    modal = request.REQUEST.get("modal", False)
    close = request.REQUEST.get("close", False)
    if modal == "true":
        template = 'user/login_modal.html'

    if not request.user.is_anonymous():
        return HttpResponseRedirect(reverse("home"))

    next = request.REQUEST.get('next', reverse('home'))

    if request.POST:
        username = request.POST['username']
        email_exists = User.objects.filter(email=username)
        if email_exists:
            username = email_exists[0].username

        password = request.POST['password']

        user = authenticate(username=username, password=password)

        if user is not None:
            if user.is_active:
                login(request, user)
                return SuccessfulSignInRedirect(next, modal, request, close=close)

        message = "Error logging you in, are you sure you're using the right credentials?"

    context ={'message' : message, 'next' : next, 'username': username, 'password': password, 'modal': modal, 'close': close }
    return render_to_response(template, context, context_instance = RequestContext(request))
Example #3
0
def initial_setup(request):
    if User.objects.all().exists():
        return redirect('/comic/')
    if request.POST:
        form = InitialSetupForm(request.POST)
        if form.is_valid():
            user = User(
                username=form.cleaned_data['username'],
                email=form.cleaned_data['email'],
                is_staff=True,
                is_superuser=True,
            )
            user.set_password(form.cleaned_data['password'])
            user.save()
            base_dir, _ = Setting.objects.get_or_create(name='BASE_DIR')
            base_dir.value = form.cleaned_data['base_dir']
            base_dir.save()
            user = authenticate(username=form.cleaned_data['username'],
                                password=form.cleaned_data['password'])
            login(request, user)
            return redirect('/comic/')
    else:
        form = InitialSetupForm()
    context = {
        'form': form,
        'title': 'CBWebReader - Setup',
        'error_message': form.errors,
    }
    return render(request, 'comic/settings_page.html', context)
Example #4
0
    def post(self,request,*args,**kwargs):
        
        username = request.POST['usuario']
        password = request.POST['password']
        user  = authenticate(username=username,password=password)
        if user is not None:
            
            if user.is_active:
                request.session['usuario'] = user.id #sets the exp. value of the session 
                login(request, user) #the user is now logged in
            # if request.user.is_authenticated():
            #     mensaje = u'¡Ha cerrado sesión correctamente!'
            #     messages.info(self.request, mensaje)
            # return redirect(reverse_lazy('login'))
                # return render(request, 'rcs/dashboard.html',context)
                return redirect(reverse_lazy('dashboard'))
            else:
                return redirect(reverse_lazy('login'))

        else:
            mensaje_error= 'El usuario o contraseña es invalido.'
            errors = {
                'mensaje_error': mensaje_error,
            }
            return render(request, 'index.html', errors)
Example #5
0
def perform_login(request, user, redirect_url=None):
    from .models import EmailAddress

    # not is_active: social users are redirected to a template
    # local users are stopped due to form validation checking is_active
    assert user.is_active
    if (app_settings.EMAIL_VERIFICATION == EmailVerificationMethod.MANDATORY
        and not EmailAddress.objects.filter(user=user,
                                            verified=True).exists()):
        send_email_confirmation(request, user)
        return render(request,
                      "account/verification_sent.html",
                      { "email": user.email })
    # HACK: This may not be nice. The proper Django way is to use an
    # authentication backend, but I fail to see any added benefit
    # whereas I do see the downsides (having to bother the integrator
    # to set up authentication backends in settings.py
    if not hasattr(user, 'backend'):
        user.backend = "django.contrib.auth.backends.ModelBackend"
    signals.user_logged_in.send(sender=user.__class__, 
                                request=request, 
                                user=user)
    login(request, user)
    messages.add_message(request, messages.SUCCESS,
                         ugettext("Successfully signed in as %(user)s.") % { "user": user_display(user) } )

    redirect_url = (redirect_url 
                    or get_next_redirect_url(request) 
                    or get_adapter().get_login_redirect_url(request))
    return HttpResponseRedirect(redirect_url)
Example #6
0
def doLogin(request):
    user = authenticate(username=request.POST["username"], password=request.POST["password"])
    if user is not None:
        login(request, user)
        return redirect('/importlist/')
    else:
        return redirect('/?error=用户名或密码错误!')
def login_user(request):
    state = "Por favor ingrese a continuacion"
    username = password = ''
    if request.POST:
        username = request.POST.get('username')
        password = request.POST.get('password')

        user = authenticate(username=username, password=password)
        if user is not None:
            if user.is_active:
                login(request, user)
                state = "Conectado con exito"
                usuario = User.objects.get(username=username)
                fotourl = usuario.estudiante.foto.url
                cedula = usuario.estudiante.cedula
                telefono = usuario.estudiante.telefono
                fecha = datetime.datetime.today()
                programa = usuario.estudiante.programa.nombre_del_programa
                duracion = usuario.estudiante.fecha_de_expiracion
                startdate = datetime.date.today()
                enddate = startdate + datetime.timedelta(days=6)
                talleres = Taller.objects.filter(fecha__range=[startdate, enddate])



                # .filter(hora_inicio__gt=time.strftime("%H:%M:%S"))
                return render(request,'contenido.html',{'username':username,'fecha':fecha,'fotourl':fotourl,'cedula':cedula,'telefono':telefono,'programa':programa,'duracion':duracion,'talleres':talleres})
            else:
                state = "Tu cuenta esta desactivada por favor acercarce a oficinas."
        else:
            state = "Usuario o contrasena incorrecta"

    return render(request,'signin.html',{'state':state}, context_instance=RequestContext(request))
Example #8
0
 def form_valid(self, form):
     super(SignUp, self).form_valid(form)
     form.save()
     user = authenticate(username=form.cleaned_data.get('username'),
                         password=form.cleaned_data.get('password1'))
     login(self.request, user)
     return redirect(reverse('index'))
Example #9
0
    def original_process_request(self, request):
        # AuthenticationMiddleware is required so that request.user exists.
        if not hasattr(request, 'user'):
            raise ImproperlyConfigured(
                "The Django remote user auth middleware requires the"
                " authentication middleware to be installed.  Edit your"
                " MIDDLEWARE_CLASSES setting to insert"
                " 'django.contrib.auth.middleware.AuthenticationMiddleware'"
                " before the RemoteUserMiddleware class.")
        if self.header not in request.META:
            return
        username = request.META[self.header]
        username, sep, domain = username.partition('@')
        # If the user is already authenticated and that user is the user we are
        # getting passed in the headers, then the correct user is already
        # persisted in the session and we don't need to continue.
        if request.user.is_authenticated():
            if request.user.get_username() == self.clean_username(username, request):
                return
            else:
                # An authenticated user is associated with the request, but
                # it does not match the authorized user in the header.
                self._remove_invalid_user(request)

        # We are seeing this user for the first time in this session, attempt
        # to authenticate the user.
        user = auth.authenticate(remote_user=username)
        if user:
            # User is valid.  Set request.user and persist user in the session
            # by logging the user in.
            request.user = user
            auth.login(request, user)
Example #10
0
def login_and_forward(request, user, forward=None, message=None):
    if user.is_suspended():
        return forward_suspended_user(request, user)

    user.backend = "django.contrib.auth.backends.ModelBackend"
    login(request, user)

    if message is None:
        message = _("Welcome back %s, you are now logged in") % user.username

    request.user.message_set.create(message=message)

    if not forward:
        forward = request.session.get(ON_SIGNIN_SESSION_ATTR, reverse('index'))

    pending_data = request.session.get(PENDING_SUBMISSION_SESSION_ATTR, None)

    if pending_data and (user.email_isvalid or pending_data['type'] not in settings.REQUIRE_EMAIL_VALIDATION_TO):
        submission_time = pending_data['time']
        if submission_time < datetime.datetime.now() - datetime.timedelta(minutes=int(settings.HOLD_PENDING_POSTS_MINUTES)):
            del request.session[PENDING_SUBMISSION_SESSION_ATTR]
        elif submission_time < datetime.datetime.now() - datetime.timedelta(minutes=int(settings.WARN_PENDING_POSTS_MINUTES)):
            user.message_set.create(message=(_("You have a %s pending submission.") % pending_data['data_name']) + " %s, %s, %s" % (
                html.hyperlink(reverse('manage_pending_data', kwargs={'action': _('save')}), _("save it")),
                html.hyperlink(reverse('manage_pending_data', kwargs={'action': _('review')}), _("review")),
                html.hyperlink(reverse('manage_pending_data', kwargs={'action': _('cancel')}), _("cancel"))
            ))
        else:
            return manage_pending_data(request, _('save'), forward)

    return HttpResponseRedirect(forward)
Example #11
0
def create(request):
    # shipping_opts = shipping.util.get_session(request)
    initial = {
        # 'country': shipping_opts.get('country'),
    }

    if request.method == 'POST':
        account_form = AccountForm(request.POST, initial=initial)
        user_form = CreateUserForm(request.POST)
        if account_form.is_valid() and user_form.is_valid():
            account = account_form.save(commit=False)
            account.user = user_form.save()
            account.save()
            auth_user = authenticate(
                username=account.user.username,
                password=user_form.cleaned_data['password1'])
            login(request, auth_user)
            messages.info(request, 'Your account was created.')
            return redirect(details)
    else:
        account_form = AccountForm(initial=initial)
        user_form = CreateUserForm()

    return {
        'account_form': account_form,
        'user_form': user_form,
    }
Example #12
0
def invitation_retrieve(request, response_format='html'):
    "Retrieve invitation and create account"
    
    if request.user.username:
        return HttpResponseRedirect('/')
    
    email = request.REQUEST.get('email', None)
    key = request.REQUEST.get('key', None)
    if email and key:
        try:
            invitation = Invitation.objects.get(email=email, key=key)
        except:
            raise Http404
    else:
        raise Http404
    
    if request.POST:
        form = InvitationForm(invitation, request.POST)
        if form.is_valid():
            profile = form.save()
            username = profile.user.username
            password = form.cleaned_data['password']
            user = authenticate(username=username, password=password)
            if user:
                invitation.delete()
                login(request, user)
                return HttpResponseRedirect('/')
    else:
        form = InvitationForm(invitation)

    return render_to_response('core/invitation_retrieve',
                              {'invitation': invitation,
                               'form': form},
                              context_instance=RequestContext(request),
                              response_format=response_format)
Example #13
0
def register(request):
    form = ChallengesRegisterForm(
        initial=request.GET,
        enable_register_club=feature_is_enabled('challenge_register_club'))
    if request.method == "POST":
        form = ChallengesRegisterForm(request.POST, enable_register_club=feature_is_enabled('challenge_register_club'))
        if form.is_valid():
            username = form.cleaned_data.get('email_address')
            password = form.cleaned_data.get('password')
            user = User.objects.create_user(username, username, password)
            user.save()
            user.spudder_user.mark_password_as_done()
            fan_entity = create_and_activate_fan_role(request, user)
            fan_page = fan_entity.entity
            fan_page.username = form.cleaned_data.get('username')
            fan_page.state = str(request.META.get('HTTP_X_APPENGINE_REGION')).upper()
            fan_page.save()
            login(request, authenticate(username=username, password=password))
            if feature_is_enabled('tracking_pixels'):
                EventController.RegisterEvent(request, EventController.CHALLENGER_USER_REGISTERER)
            if form.cleaned_data.get('account_type') == EntityController.ENTITY_CLUB:
                return redirect('/challenges/register/team?next=%s' % form.cleaned_data.get('next', '/'))
            return redirect(form.cleaned_data.get('next', '/'))
    return render(
        request,
        'spudderspuds/challenges/pages/register.html',
        {'form': form})
Example #14
0
def login(request):
    if request.user.is_authenticated():
        return redirect('/')
    if request.method == 'POST':
        login_form = forms.LoginForm(request.POST)
        if login_form.is_valid():
            login_name=request.POST['username'].strip()
            login_password=request.POST['password']
            user = authenticate(username=login_name, password=login_password)
            if user is not None:
                if user.is_active:
                    auth.login(request, user)
                    messages.add_message(request, messages.SUCCESS, '成功登录了')
                    return redirect('/')
                else:
                    messages.add_message(request, messages.WARNING, '账号尚未启用')
            else:
                messages.add_message(request, messages.WARNING, '登录失败')
        else:
            messages.add_message(request, messages.INFO,'请检查输入的字段内容')
    else:
        login_form = forms.LoginForm()

    template = get_template('login.html')
    request_context = RequestContext(request)
    request_context.push(locals())
    html = template.render(request_context)
    return HttpResponse(html)
Example #15
0
    def handle_anonymous_user(self, response):
        """
        Handles the ULogin response if user is not authenticated (anonymous)
        """
        try:
            ulogin = ULoginUser.objects.get(network=response['network'],
                                            uid=response['uid'])
        except ULoginUser.DoesNotExist:
            user = create_user(request=self.request,
                               ulogin_response=response)
            ulogin = ULoginUser.objects.create(user=user,
                                               network=response['network'],
                                               identity=response['identity'],
                                               uid=response['uid'])
            registered = True
        else:
            user = ulogin.user
            registered = False

        # Authenticate user
        if not hasattr(user, 'backend'):
            user.backend = settings.AUTHENTICATION_BACKEND
        login(self.request, user)

        return user, ulogin, registered
Example #16
0
def ingreso(request):
    state = "Por favor ingrese su usuario y contraseña..."
    username = password = ''
    context = {}
    context.update(csrf(request))

    next = "/"
    if request.GET:
        next = request.GET['next']

    if request.POST:
        username = request.POST.get('username')
        password = request.POST.get('password')
        user = authenticate(username=username, password=password)
        if user is not None:
            if user.is_active:
                login(request, user)
                return HttpResponseRedirect(next)
            else:
                state = "Su cuenta no está activa, por favor contactese\
                con el administrador."
        else:
            state = '<div style="color:red">\
            <span class="glyphicon glyphicon-warning-sign"></span> \
            Su usuario y/o su contraseña son incorrectos.</div>'

    context['state'] = state
    context['username'] = username
    context['next'] = next

    return render_to_response('ingreso.html', context)
Example #17
0
def user_login(request):

    # If request is POST, pull out relevant information
    if request.method == 'POST':
        # Gather the username and password provided the user from the login form
        username = request.POST.get('username')
        password = request.POST.get('password')

        # Use django's own authenticate method to see if the username and password combination is correct.
        user = authenticate(username=username, password=password)

        # If the user state exists
        if user:

            # Check if the user account is active (could be disabled).
            if user.is_active:
                # If the user is valid and active, log the user in.
                login(request, user)
                return HttpResponseRedirect('/rango/')
            else:
                # If an inactive account was used.
                return HttpResponse('Your Rango account is disabled.')

        else:
            # Bad login details were provided. Unsuccessful login.
            print 'Invalid login details: {0}, {1}'.format(username, password)
            return HttpResponse('Invalid login details supplied.')

    else:
        return render(request, 'rango/login.html', {})
Example #18
0
def login(request):

    data=dict()
    if request.method == 'GET':
        next = request.GET.get('next')
        data['next'] = next
        # backgroundimg = memcache.Client(['127.0.0.1']).get('background')
        data['img'] = memcache.Client(['127.0.0.1']).get('background')
        return render_to_response('login.html',data, context_instance=RequestContext(request))
    else:
        username=request.POST.get('username')
        password=request.POST.get('password')
        if username != '' and password != '':
            try:
                User.objects.get(username=username)
                user = auth.authenticate(username=username, password=password)
                if user is not None:
                    if user.is_active == False:
                        data['is_succ'] = False
                        data['msg'] = '用户账号已禁用'
                    else:
                        auth.login(request, user)
                        data['name'] = user.name
                        data['is_succ']=True
                else:
                    data['is_succ']=False
                    data['msg']='账户或密码错误'
            except:
                data['is_succ']=False
                data['msg']='用户不存在'

        return HttpResponse(json.dumps(data), content_type='application/json')
Example #19
0
def thanks(request, redirect_url=settings.LOGIN_REDIRECT_URL):
    # tokens obtained from Twitter
    oauth_token = request.session['request_token']['oauth_token']
    oauth_token_secret = request.session['request_token']['oauth_token_secret']
    twitter = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET,
                      oauth_token, oauth_token_secret)

    # retrieving tokens
    authorized_tokens = twitter.get_authorized_tokens(request.GET['oauth_verifier'])

    # if tokens already exist, use them to login and redirect to the battle
    try:
        user = User.objects.get(username=authorized_tokens['screen_name'])
        user.set_password(authorized_tokens['oauth_token_secret'])
        user.save()
    except User.DoesNotExist:
        # mock a creation here; no email, password is just the token, etc. since no need for users in this app
        user = User.objects.create_user(authorized_tokens['screen_name'], "*****@*****.**", authorized_tokens['oauth_token_secret'])
        profile = TwitterProfile()
        profile.user = user
        profile.oauth_token = authorized_tokens['oauth_token']
        profile.oauth_secret = authorized_tokens['oauth_token_secret']
        profile.save()

    user = authenticate(
        username=authorized_tokens['screen_name'],
        password=authorized_tokens['oauth_token_secret']
    )

    login(request, user)
    return HttpResponseRedirect(redirect_url)
Example #20
0
def login_view(request):

    context = {}

    context['form'] = UserLogin(initial={'next_page': request.GET.get('next')})
    if request.method == "POST":
        form = UserLogin(request.POST)
        if form.is_valid():

            username = form.cleaned_data['username']
            password = form.cleaned_data['password']
            next_page = form.cleaned_data['next_page']
            auth_user = authenticate(username=username, password=password)

            if auth_user is not None:
                if auth_user.is_active:
                    login(request, auth_user)
                    context['valid'] = "Login Successful"
                    print next_page
                    if next_page == None or next_page == "":
                        return redirect('candidate_list_view')
                    else:
                        return redirect(next_page)
                else:
                    context['valid'] = "Invalid User"
            else:
                context['valid'] = "Login Failed! Try again"


    return render_to_response('login_view.html', context, context_instance=RequestContext(request))
Example #21
0
def register(request):
    data = dict()
    username =request.POST.get('username')
    email=request.POST.get('email')
    password=request.POST.get('password')
    name = request.POST.get('name')

    if User.objects.filter(username=username):
        data['is_succ']=False
        data['msg'] = '用户名已存在'
    elif User.objects.filter(email = email,is_active = True):
        data['is_succ']=False
        data['msg'] = '邮箱已注册'
    elif User.objects.filter(name = name,is_active = True):
        data['is_succ']=False
        data['msg'] = '短名已存在'
    else:
        try:
            User.objects.create_user(username=username,email=email,password=password,name=name,blog_name=request.POST.get('blog_name'))
            user = auth.authenticate(username=username, password=password)
            auth.login(request,user)
            param = dict()
            param['user'] = user
            send_html_mail('博客注册成功',loader.render_to_string('template_email/success_register.html',param),email)
            data['name'] = user.name
            data['is_succ']=True
        except :
            data['is_succ'] =False
            data['msg'] = '注册失败'
    return HttpResponse(json.dumps(data), mimetype='application/json')
Example #22
0
def userlogin(request):
    if request.user.is_authenticated():
        return redirect('IndexViewWeb')
    else:
        if request.method == "POST":
            if 'login_form' in request.POST:
                login_form = userLoginForm(request.POST)
                if login_form.is_valid():
                    user = authenticate(username=login_form.cleaned_data[
                                        'username'], password=login_form.cleaned_data['password'])
                    if user is not None:
                        if user.is_active:
                            try:
                                login(request, user)
                                return redirect('indexDashboard')
                            except:
                                errors = '''
                                    <div class="card-panel teal lighten-2">User Activo</div>
                                '''
                                return render(request, 'login.html', {'login_form': login_form, 'errors': errors})
                    else:
                        errors = '''
                                    <div class="card-panel red lighten-2"><span class="white-text">Usuario y/o contraseña incorrecta.</span></div>
                                '''
                        return render(request, 'login.html', {'login_form': login_form, 'errors': errors})
                else:
                    raise Exception('Error Login : Form incomplete')
        else:
            errors = ''
            login_form = userLoginForm()
            return render(request, 'login.html', {'login_form': login_form, 'errors': errors})
Example #23
0
    def done(self, form_list, **kwargs):
        user = self.get_user()
        login(self.request, user)

        if not self.request.user.info.registration_finished:
            # If the user has not finished registration yet, redirect them there to finish it now.
            redirect_to = reverse('register')
        else:
            redirect_to = self.request.POST.get(
                self.redirect_field_name,
                self.request.GET.get(self.redirect_field_name, '')
            )
            if not is_safe_url(url=redirect_to, host=self.request.get_host()):
                redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)

        device = getattr(user, 'otp_device', None)

        if device:
            if isinstance(device, StaticDevice):
                # User logged in using a static backup code, refresh it with a new one.
                device.token_set.create(token=StaticToken.random_token())

            signals.user_verified.send(
                sender=__name__,
                request=self.request,
                user=user,
                device=device
            )

        # Track login type in Segment.
        analytics.track(user.id, 'user-login', {
            'login_type': 'Traditional',
        })

        return redirect(redirect_to)
Example #24
0
File: views.py Project: grv07/clat
def teacher_login(request):
	if request.user.is_authenticated():
		messages.info(request,'Please logout first and then re-login with a different account.')
		return HttpResponseRedirect('/home/')
	if request.method == 'POST':
		t_username = request.POST.get('username')
		t_password = request.POST.get('password')
		try:
			t_user = authenticate(username=t_username, password=t_password)
			teacher = Teacher.objects.get(pk=t_user.id)
		except Exception as e:
			t_user = None
			teacher = None
		if teacher is not None:
			if t_user.is_active:
				login(request, t_user)
				messages.success(request,'You logged in successfully.')
				return HttpResponseRedirect('/teacher/')
			else:
				messages.warning(request,'Your account is not yet active.')
				return render(request, 'teacher/login_teacher.html', {'t_not_active': True, 'next': request.POST.get('next')})
		else:
			course_list = CourseDetail.objects.all()
			course_list = pagination.get_paginated_list(obj_list=course_list,page = request.GET.get('page'))
			messages.error(request,'Please enter valid credentials.')
			return render(request, 'teacher/login_teacher.html', {'t_login_error': True, 'next': request.POST.get('next')})
	else:
		return render(request,'teacher/login_teacher.html',{})
Example #25
0
def activate(request, activation_link=None):
    """ Activate new user account and delete related user demand object. """
    if activation_link == None:
        ctx = {
            'form': RegisterForm,
            'title': _('Sign Up'),
        }
        return render(request, 'userspace/register.html', ctx)
    try:
        demand = RegisterDemand.objects.get(activation_link=activation_link)
    except RegisterDemand.DoesNotExist:
        # TODO wypadałoby coś tutaj pokazać.
        return HttpResponse(_("Activation link invalid"))
    user = demand.user
    lang = demand.lang
    if user is not None:
        user.is_active = True
        user.save()
        user.profile.lang = lang
        user.profile.save()
        demand.delete()
        update_profile_picture(user.profile, get_gravatar_image(user.email))
        system_user = auth.authenticate(username=user.username)
        if system_user is not None:
            auth.login(request, system_user)
        request.session['new_user'] = True
        return redirect(reverse('user:active'))
Example #26
0
def voter_authenticate_manually_process_view(request):
    voter_api_device_id = get_voter_api_device_id(request)  # We look in the cookies for voter_api_device_id
    voter_id = fetch_voter_id_from_voter_device_link(voter_api_device_id)

    voter_id = convert_to_int(voter_id)
    voter_signed_in = False
    try:
        voter_on_stage = Voter.objects.get(id=voter_id)
        # If the account associated with this voter_api_device_id is an admin, complete Django authentication
        if voter_on_stage.is_admin:
            voter_on_stage.backend = 'django.contrib.auth.backends.ModelBackend'
            login(request, voter_on_stage)
            messages.add_message(request, messages.INFO, 'Voter logged in.')
            voter_signed_in = True
        else:
            messages.add_message(request, messages.INFO, 'This account does not have Admin access.')
    except Voter.MultipleObjectsReturned as e:
        handle_record_found_more_than_one_exception(e, logger=logger)
        messages.add_message(request, messages.ERROR, 'More than one voter found. Voter not logged in.')
    except Voter.DoesNotExist:
        # This is fine, we will display an error
        messages.add_message(request, messages.ERROR, 'Voter not found. Voter not logged in.')

    if voter_signed_in:
        return HttpResponseRedirect(reverse('admin_tools:admin_home', args=()))
    else:
        return HttpResponseRedirect(reverse('voter:authenticate_manually', args=()))
Example #27
0
def submitRegistration(request):
    if request.method == 'POST':
        username = request.POST['username'].strip()
        email = request.POST['email'].strip()
        password = request.POST['password'].strip()

        if User.objects.filter(username=username):
            data = {'error':'This username is already taken.'}
        elif User.objects.filter(email=email):
            data = {'error':'This email is already used with another account.'}
        else:
            user = User.objects.create_user(username, email, password)
            
            #check to see if user is logged in
            if user:
                user.backend = 'django.contrib.auth.backends.ModelBackend'
                login(request, user)
                
            request.session['user_id'] = user.id
            request.session.set_expiry(604800)
            data = {'success':'success'}

    else:
        data = {'error':'Did not post correctly'}
    return HttpResponse(json.dumps(data))
Example #28
0
def userRegister(request):
    if request.method == "POST":
        if 'register_form' in request.POST:
            user_register = userRegisterForm(request.POST)
            if user_register.is_valid():
                user_register.save(commit=False)
                User.objects.create_user(first_name=user_register.cleaned_data['first_name'],
                                         username=user_register.cleaned_data['username'],
                                         last_name=user_register.cleaned_data['last_name'],
                                         email=user_register.cleaned_data['email'],
                                         password=user_register.cleaned_data['password'],
                                         type_user=0,
                                         )
                user = authenticate(username=user_register.cleaned_data['username'],
                                    password=user_register.cleaned_data['password'])

                if user is not None:
                    if user.is_active:
                        try:
                            login(request, user)
                            return redirect('indexWeb')
                        except:
                            raise Exception('Error : Username or Password is incorrect')
                    else:
                        raise Exception('Error : Username not exist')
            else:
                raise Exception('Error Register : Form incomplete')
    else:
        user_register = userRegisterForm()
        return render(request, 'registro.html', {'user_register': user_register})
Example #29
0
def sign_up( request, template_name = 'accounts/sign_up.html' ):
    """
    Processes requests for new user registration. If method is being
    accessed via GET, this displays the appropriate form. If via POST,
    this validates request and, after saving the new user in the database,
    logs in the user and redirects to the settings page.
    """
    if request.method == 'POST':
        postdata = request.POST.copy()
        form = CustomUserCreationForm( postdata )
        if form.is_valid():
            form.save()
            username = postdata.get( 'username', '' )   # get username, or blank string if not available
            password = postdata.get( 'password1', '' )  # password1 is referenced on django.contrib.auth.forms.py line 17.
                                                        # password2 is the confirmation password input on the form.
            from django.contrib.auth import login, authenticate
            new_user = authenticate( username = username, password = password )
            if new_user and new_user.is_active: # if new_user is not None:
                login( request, new_user )
                url = urlresolvers.reverse( 'settings' )    # redirect to settings page
                return HttpResponseRedirect( url )
    else:   # if request.method == 'GET':
        form = CustomUserCreationForm() # build UserCreationForm()
    page_title = 'Sign Up'
    return render_to_response( template_name, locals(), context_instance = RequestContext( request ) )  
Example #30
0
def signup(request):

    context = {}

    form = CustomUserCreateForm()
    context['form'] = form

    if request.method == 'POST':
        form = CustomUserCreateForm(request.POST)
        if form.is_valid():
            print form.cleaned_data

            email = form.cleaned_data['email']
            password = form.cleaned_data['password1']
            password2 = form.cleaned_data['password2']
            if password == password2:
                try:
                    new_user = CustomUser.objects.create_user(email, password)
                    context['valid'] = "Thank You For Signing Up!"

                    auth_user = authenticate(username=email, password=password)
                    login(request, auth_user)

                    return redirect('candidate_list_view')

                except IntegrityError, e:
                    context['valid'] = "A User With That Name Already Exists"
            else:
                context['valid'] = "Your passwords didn't match!"

        else:
            context['valid'] = form.errors
Example #31
0
def login_view(request):
    if not request.session.exists(request.session.session_key):
        request.session.create()
    print (request.session.session_key)
    if request.user.is_authenticated():
        return redirect(reverse('accounts.index'))

    mensaje = ''
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        user = authenticate(username=username, password=password)
        if user is not None:
            if user.is_active:
                login(request, user)
                return redirect(reverse('accounts.index'))
            else:
                login(request, user)
                return redirect(reverse('accounts.login'))
        mensaje = 'Nombre de usuario o contraseña no valido'
        
    return render(request, 'accounts/login.html', {'mensaje': mensaje})
Example #32
0
def signup_user_view(request):
    if request.method == 'POST':
        form = SignupForm(request.POST)
        if form.is_valid():
            user = form.save()
            user.refresh_from_db() # Carga la instancia de perfil crada por signal
            user.perfil.birth_date = form.cleaned_data.get('birth_date')
            user.perfil.user_name = form.cleaned_data.get('user_name')
            user.perfil.user_last = form.cleaned_data.get('user_last')
            user.first_name = user.perfil.user_name
            user.last_name = user.perfil.user_last
            user.perfil.email = user.email
            user.save()
            # user.perfil.save()
            raw_password = form.cleaned_data.get('password1')
            user = authenticate(username = user.username, password = raw_password)
            login(request, user)
            return redirect('/profile/')

    else:
        form = SignupForm()
    return render(request, 'pagina/register.html', {'form': form})
Example #33
0
def sign_in(request):
    r = request

    body = json.loads(r.body)

    if body is None:
        return JsonResponse({'status': False})

    email = body.get('email', None)
    password = body.get('password', None)

    if email is None or password is None:
        return JsonResponse({'status': False})

    user = authenticate(username=email, password=password)

    if user is not None:
        login(request, user)
        permissions = [x.codename for x in Permission.objects.filter(user=user)]
        return JsonResponse({'status': True, 'permissions': permissions})

    return JsonResponse({'status': False})
Example #34
0
def signup_customer(request):
    if request.method == 'POST':
        form = SignUpCustomerForm(request.POST)
        if form.is_valid():
            # Applies Profile fields
            user = form.save()
            user.refresh_from_db()
            user.save()
            #user.profile.birth_date = form.cleaned_data.get('birth_date')
            #user.profile.bio = form.cleaned_data.get('bio')

            # User requirements
            username = form.cleaned_data.get('username')
            #raw_password = form.cleaned_data.get('password')
            #user = authenticate(username=username, password=raw_password)

            # Redirect home, new User is logged in
            login(request, user)
            return redirect('home')
    else:
        form = SignUpCustomerForm()
    return render(request, 'registration/signup_customer.html', {'form': form})
Example #35
0
    def post(self, request):
        form = LoginForm(request.POST)

        if form.is_valid():
            this = form.cleaned_data
            user = authenticate(username=this.get('Username'),
                                password=this.get('Password'))

            if user is not None:
                login(request, user)
                return render(request, 'logged.html', {'user': user})
            else:
                return render(
                    request, 'login.html', {
                        'form': LoginForm(),
                        'error': 'Invalid Username/Password Combination'
                    })
        else:
            return render(request, 'login.html', {
                'form': form,
                'error': 'Invalid Username/Password Combination'
            })
Example #36
0
def user_login(request):

    if request.method == "POST":
        username = request.POST.get('username')
        password = request.POST.get('password')

        user = authenticate(username=username, password=password)

        if user:
            if user.is_active:
                login(request, user)
                return HttpResponseRedirect(reverse('index'))

            else:
                return HttpResponse("ACCOUNT NOT ACTIVE")
        else:
            print("Someone tried to login and failed")
            print("Userrname: {} and password: {}".format(username, password))
            return HttpResponse("Invalid Login Details")

    else:
        return render(request, 'login.html', {})
Example #37
0
def signup(request):
	if request.method == 'POST':
		if request.POST['password1'] == request.POST['password2']:
			if len(request.POST['password1']) < 5:
				return render(request,'accounts/signup.html', {'error':'- Please choose a stronger password -'})	

			else:
				try:
					user = User.objects.get(username=request.POST['username'])
					return render(request,'accounts/signup.html', {'error':'- Username is already taken -'})
			
				except User.DoesNotExist:
					user = User.objects.create_user(request.POST['username'], password = request.POST['password1'])
					auth.login(request, user)
					return redirect('home')

		else:
			return render(request,'accounts/signup.html', {'error':'- Passwords do not match -'})	


	else:
		return render(request,'accounts/signup.html')
Example #38
0
def login_view(request):
    if request.method == 'POST':

        form = LoginForm(request.POST)
        if form.is_valid():
            u = form.cleaned_data['username']
            p = form.cleaned_data['password']
            user = authenticate(username=u, password=p)
            if user is not None:
                if user.is_active:
                    login(request, user)
                    print("user is active")
                    return HttpResponseRedirect('/show')
                else:
                    print("The account has been disabled.")
                return HttpResponseRedirect('/')
            else:
                print("The username and/or password is incorrect.")
            return HttpResponseRedirect('/')
    else:
        form = LoginForm()
    return render(request, 'login.html', {'form': form})
def login_user(request):
    if request.method == 'POST':
        # form = LoginForm()
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return redirect('/')
        else:
            messages.warning(request,
                             'هناك خطأ في اسم المستخدم او كلمة المرور')

    # else:
    #     form = LoginForm()
    return render(
        request,
        'login.html',
        {
            'title': 'تسجيل الدخول',
            # 'form': form,
        })
Example #40
0
    def create_user(self, nickname, wgid):
        realm = 'NA'
        # resolve realm
        if realm == 'NA':
            realm_url = 'com'
        elif realm == 'EU':
            realm_url = 'eu'
        elif realm == 'SEA':
            realm_url = 'asia'


        try:
            user = User.objects.get(username__exact=nickname)

        except ObjectDoesNotExist:
            password = User.objects.make_random_password(length=255)
            user = User.objects.create_user(nickname, '', password)
            user.first_name = nickname

            # try to find Player object
            p, was_created = Player.objects.get_or_create(player_wgid=wgid)
            p.player_nickname = nickname
            user.player = p

            # get clan 
            payload = {
                'application_id': api_key,
                'account_id': wgid,
            }
            response = requests.get(f"https://api.worldofwarships.{realm_url}/wows/clans/accountinfo/", params=payload)
            page_query = json.loads(response.text)
            clan_id = page_query['data'][wgid]['clan_id']
            c, was_created = Clan.objects.get_or_create(clan_wgid=clan_id, clan_realm=realm)
            p.player_clan = c
            user.save()
            p.save()

        login(self.request, user)
        return user 
Example #41
0
def webapp_login(request):

    try:
        post_data = json.loads(request.body)
    except ValueError:
        return HttpResponseBadRequest()

    if 'username' not in post_data or 'password' not in post_data:
        return HttpResponseBadRequest()

    print(post_data)
    user_name = post_data.get('username')
    password = post_data.get('password')

    user = authenticate(username=user_name, password=password)

    if not user:
        return HttpResponseForbidden()

    login(request, user)

    return JsonResponse(data={'status': 'OK', 'token': str(Token.objects.get(user=user))})
Example #42
0
def login_view(request):
    data = {'next': request.GET.get('next', '')}
    try:
        username = request.POST['username']
        password = request.POST['password']
    except KeyError:
        return render(request, 'cardbox/login.html', data)

    user = authenticate(username=username, password=password)
    if user is not None:
        if user.is_active:
            login(request, user)
            next_url = request.POST.get('next', '')
            if next_url == '':
                return HttpResponseRedirect(reverse('cardbox:index'))
            return HttpResponseRedirect(next_url)
        else:
            messages.add_message(request, messages.WARNING, 'User not active!')
            return render(request, 'cardbox/login.html', data)
    else:
        messages.add_message(request, messages.WARNING, 'User not found!')
        return render(request, 'cardbox/login.html', data)
Example #43
0
    def post(self, request):
        form = self.form_class(request.POST)
        next_ = request.POST.get('next', settings.LOGIN_REDIRECT_URL)
        if next_ == '':
            next_ = settings.LOGIN_REDIRECT_URL
        if form.is_valid():
            username = form.cleaned_data['username']
            password = form.cleaned_data['password']
            remember = form.cleaned_data['remember']

            user = authenticate(username=username, password=password)
            if user is not None:
                if remember:
                    # Yearlong Session
                    request.session.set_expiry(24*365*3600)
                else:
                    request.session.set_expiry(0)
                login(request, user)
                return redirect(next_)
            else:
                form.add_error(None, "Unable to authorize user. Try again!")
        return render(request, self.template_name, {'form': form})
Example #44
0
def register(request):
    if request.method == "POST":
        form = NewUserForm(request.POST)
        if form.is_valid():
            user = form.save()
            username = form.cleaned_data.get('username')
            messages.success(request, f"New account created: {username}")
            login(request, user)
            return redirect("main:homepage")

        else:
            for msg in form.error_messages:
                messages.error(request, f"{msg}: {form.error_messages[msg]}")

            return render(request = request,
                          template_name = "main/register.html",
                          context={"form":form})

    form = NewUserForm
    return render(request = request,
                  template_name = "main/register.html",
                  context={"form":form})
Example #45
0
 def login(self, request: HttpRequest, username=None):
     user = authenticate(username=username, password=request.data['password'])
     if user is not None:
         if user.is_active:
             login(request, user)
             return HttpResponse(
                 content=json.dumps({'status': 'success'}),
                 status=201,
                 content_type='application/json'
             )
         else:
             return HttpResponse(
                 json.dumps({'detail': "don't right login or password"}),
                 status=401,
                 content_type='application/json'
             )
     else:
         return HttpResponse(
             json.dumps({'detail': "Incorrect login or password"}),
             status=401,
             content_type='application/json'
         )
Example #46
0
    def post(self, request, *args, **kwargs):
        front_url = get_front_url()
        user = self.get_object()
        username_field = self.model.USERNAME_FIELD
        impersonator_user = request.user
        impersonator_user_id = request.user.pk
        shop = get_shop(request)

        _check_for_login_as_problems(front_url, impersonator_user, user)
        _check_for_login_as_permissions(shop, impersonator_user, user)

        if not hasattr(user, 'backend'):
            for backend in django_settings.AUTHENTICATION_BACKENDS:
                if user == load_backend(backend).get_user(user.pk):
                    user.backend = backend
                    break

        login(request, user)
        request.session["impersonator_user_id"] = impersonator_user_id
        message = _("You're now logged in as {username}").format(username=user.__dict__[username_field])
        messages.success(request, message)
        return HttpResponseRedirect(front_url)
Example #47
0
def signup(request):
    if request.method == 'POST':
        u_form = STGUserRegister(request.POST)
        p_form = ProfileCreationForm(request.POST)
        if u_form.is_valid and p_form.is_valid:
            u_form.save()
            username = u_form.cleaned_data.get('username')
            raw_password = u_form.cleaned_data.get('password1')
            user = authenticate(username=username, password=raw_password)
            user = u_form.save()
            profile = p_form.save(commit=False)
            profile.user = user
            profile.save()
            login(request, user)
            if profile.user_type == "NGO":
                return redirect('posts:ngo-dashboard')
            else :
                return redirect('posts:donor-dashboard')    
    else:
        u_form = STGUserRegister()
        p_form = ProfileCreationForm()
    return render(request, 'useraccounts/signup.html', {'u_form': u_form,'p_form':p_form})
Example #48
0
def signup(request):
    if request.method == 'POST':
        if request.POST['username'] and request.POST['password1'] and request.POST['password2'] != '':
        #user wants an account
            if request.POST['password1'] == request.POST['password2']:
                try:
                    user = User.objects.get(username = request.POST['username'])
                    return render(request, 'signup.html', {'error':'Username "{}" already exists!'.format(request.POST['username'])})
                except User.DoesNotExist:
                    user = User.objects.create_user(request.POST['username'], password=request.POST['password2'])
                    auth.login(request, user)
                    return redirect('home')
            else:
                #passwords do not match
                return render(request, 'signup.html', {'error':'Passwords do not match!'})
        else:
            #fields empty
            return render(request, 'signup.html', {'error':'Fields must not be empty!'})

    else:
        #user wants to enter info
        return render(request, 'signup.html')
def init(request):
    try:
        user = User.objects.create_user('test', '*****@*****.**',
                                        'qwertz1290')
        user.save()
    except Exception:
        pass
    user = authenticate(username='******', password='******')
    login(request, user)

    f = Foo()
    f.bar = 'object 1'
    f.save()
    assign_perm(perm='change_foo', user_or_group=user, obj=f)
    assign_perm(perm='view_foo', user_or_group=user, obj=f)

    f = Foo()
    f.bar = 'object 2'
    f.save()
    assign_perm(perm='view_foo', user_or_group=user, obj=f)

    return redirect('/api/foo/')
def loginPage(request):
    lform = LoginForm(request.POST or None)
    context ={'form':lform}
   
    if request.user.is_authenticated:
        return redirect('home_page')

    if lform.is_valid():
        # print(lform.cleaned_data)
        username = lform.cleaned_data.get('email')
        password = lform.cleaned_data.get('password')
        user = authenticate(request, username = username, password = password)
        
        
        if user is not None:
            login(request, user)
            
            return redirect('home_page')
        else:
            return redirect('loginPage')
            
    return render(request, 'login.html', context)
Example #51
0
def login_user(request):
    form = SignInForm(request.POST or None)
    if request.method == "POST":
        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 render(request, 'html_pages/ask.html')
            else:
                return render(
                    request, 'html_pages/login.html', {
                        'error_message': 'Your account has been disabled',
                        'form': form
                    })
        else:
            return render(request, 'html_pages/login.html', {
                'error_message': 'Invalid login',
                'form': form
            })
    return render(request, 'html_pages/login.html', {'form': form})
Example #52
0
    def post(self, request):
        form = UserSignUpForm(data=request.POST)
        if form.is_valid():
            username = form.cleaned_data.get('username')
            password1 = form.cleaned_data.get('password1')
            password2 = form.cleaned_data.get('password2')

            if username and password1 and password2 and password1 == password2:
                user = User.objects.create_user(username=username,
                                                password=password1)
                Eleitor.objects.create(user=user)

                auth = authenticate(request,
                                    username=username,
                                    password=password1)

                if username and password1 and auth is not None:

                    login(request, auth)
                    return redirect('index')
        data = {'form': form, 'error': 'Usuário ou senha inválidos'}
        return render(request, self.template_name, data)
Example #53
0
def login_view(request):
    # if login attempt is made
    if request.method == 'POST':
        try:
            # taking input
            username = request.POST['username']
            password = request.POST['password']
            # checking for non empty fields
            assert username != '' and password != ''
            # authenticating
            user = authenticate(username=username, password=password)
            if user is None:
                raise AssertionError
        except AssertionError:
            return render(request, 'blog/login.html',
                          {'message': 'invalid credentials'})

        login(request, user)
        return HttpResponseRedirect(reverse('index'))

    # loading login page
    return render(request, 'blog/login.html')
Example #54
0
def register(request):
	"""sign in as a new user"""
	if request.method != 'POST':
		form = UserCreationForm()
	else:
		form = UserCreationForm(data=request.POST)
		
		if form.is_valid():
			#save new user
			new_user = form.save()
			tempUser = AuthUser.objects.get(username=new_user.username)
			user_profile = UsersUserinfo(user=tempUser, photo='photos/user1.jpg')
			user_profile.save()
			
			#login
			authenticated_user = authenticate(username=new_user.username,password=request.POST['password1'])
			login(request,authenticated_user)
			
			#goto blog mainpage
			return HttpResponseRedirect(reverse('blog:mainpage'))
	context ={'form': form}
	return render(request, 'users/register.html', context)
Example #55
0
def userLogin(request):
    # If the request is a HTTP POST, try to pull out the relevant information.
    if request.method == 'POST':
        # Gather the username and password provided by the user.
        # This information is obtained from the login form.
                # We use request.POST.get('<variable>') as opposed to request.POST['<variable>'],
                # because the request.POST.get('<variable>') returns None, if the value does not exist,
                # while the request.POST['<variable>'] will raise key error exception
        username = request.POST.get('username')
        password = request.POST.get('password')

        # Use Django's machinery to attempt to see if the username/password
        # combination is valid - a User object is returned if it is.
        user = authenticate(username=username, password=password)

        # If we have a User object, the details are correct.
        # If None (Python's way of representing the absence of a value), no user
        # with matching credentials was found.
        if user:
            # Is the account active? It could have been disabled.
            if user.is_active:
                # If the account is valid and active, we can log the user in.
                # We'll send the user back to the homepage.
                login(request, user)
                return HttpResponseRedirect('/')
            else:
                # An inactive account was used - no logging in!
                return HttpResponse("Your account is disabled.")
        else:
            # Bad login details were provided. So we can't log the user in.
            print ("Invalid login details!")
            return HttpResponse("Invalid login details supplied.")

    # The request is not a HTTP POST, so display the login form.
    # This scenario would most likely be a HTTP GET.
    else:
        # No context variables to pass to the template system, hence the
        # blank dictionary object...
        return render(request, 'userLogin.html', {})
Example #56
0
    def post(self, request):
        form = self.form_class(request.POST)

        if form.is_valid():

            user = form.save(commit=False)

            username = form.cleaned_data['username']
            password = form.cleaned_data['password']
            user.set_password(password)
            user.save()
            return redirect('start')

            user = authenticate(username=username, password=password)

            if user is not None:

                if user.is_active:
                    login(request, user)
                    return redirect('start')

        return render(request, self.template_name, { 'form': form })
Example #57
0
    def post(self, request):
        data = json.loads(request.body.decode())
        csrf_token = request.COOKIES.get('csrftoken')
        username_byte = base64.b64decode(data.get("username", None))
        password_byte = base64.b64decode(data.get("password", None))
        comfirm_pass_reg_byte = base64.b64decode(data.get(
            "comfirm_pass", None))
        if None in [username_byte, password_byte, comfirm_pass_reg_byte]:
            return JsonResponse({"error": 402, "errmsg": "参数不全!"})
        try:
            password = password_byte.decode().replace(
                re.search(csrf_token, password_byte.decode()).group(), "")
            comfirm_pass = comfirm_pass_reg_byte.decode().replace(
                re.search(csrf_token, comfirm_pass_reg_byte.decode()).group(),
                "")

        except:
            return JsonResponse({"errno": 403, "errmsg": "未知错误!"})
        if password != comfirm_pass:
            return JsonResponse({"errno": 403, "errmsg": "密码不一致!"})
        try:
            username = username_byte.decode().replace(
                re.search(csrf_token, username_byte.decode()).group(), "")
        except:
            return JsonResponse({"errno": 403, "errmsg": "未知错误!"})
        user = authenticate(username=username, password=password)
        if user:
            return JsonResponse({"errno": 403, "errmsg": "用户已存在!"})
        try:
            user = User.objects.create_user(username=username,
                                            password=password)
            user.save()
            # 添加到session
            request.session['username'] = username
            login(request, user)
            # 重定向到首页
            return JsonResponse({"errno": 201, "errmsg": "注册成功!"})
        except Exception as e:
            return JsonResponse({"errno": 403, "errmsg": e})
    def form_valid(self, form):
        request = self.request

        # If the test cookie worked, go ahead and delete it since its no longer needed
        if request.session.test_cookie_worked():
            request.session.delete_test_cookie()

        # The default Django's "remember me" lifetime is 2 weeks and can be changed by modifying
        # the SESSION_COOKIE_AGE settings' option.
        if settings.USE_REMEMBER_ME:
            if not form.cleaned_data['remember_me']:
                request.session.set_expiry(0)

        login(request, form.user_cache)

        redirect_to = request.POST.get(REDIRECT_FIELD_NAME, request.GET.get(REDIRECT_FIELD_NAME))
        url_is_safe = is_safe_url(redirect_to, allowed_hosts=request.get_host(), require_https=request.is_secure())

        if url_is_safe:
            return redirect(redirect_to)

        return redirect(settings.LOGIN_REDIRECT_URL)
Example #59
0
def user_login(request):
    message = ""
    if request.method == "POST":
        form = LoginForm(request.POST)
        if form.is_valid():
            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 redirect('/home')
                else:
                    message = "無效的帳號或密碼!"
    else:
        form = LoginForm()
    return render_to_response('login.html', {
        'message': message,
        'form': form
    },
                              context_instance=RequestContext(request))
Example #60
0
    def get(self, request, *args, **kwargs):
        """
        代表登录
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        form = UserForm(request.GET)
        result = form.is_valid()
        if not result:
            default_log.error(form.errors.as_json())
            raise MyException()

        user = authenticate(username=form.cleaned_data["username"],
                            password=form.cleaned_data["password"])
        print("UsersView-get", user)
        if user:
            login(request, user)  # 登录持久化, 生成session
            return response_success("登录成功")
        else:
            raise MyException(message="登录失败")