Example #1
0
def new_account(request):
    if request.POST:
        name_first = request.POST.get('new_name_first')
        name_last = request.POST.get('new_name_last')
        email = request.POST.get('new_email')
        username = request.POST.get('new_username')
        password = request.POST.get('new_password')
        try:
            user = User.objects.create_user(username, email, password)
            user.first_name = name_first
            user.last_name = name_last
        except IntegrityError as e:
            messages.error(request, e)
            return redirect('home')
        try:
            user.full_clean()
        except ValidationError as e:
            for err in e.message_dict:
                messages.error(request, err)
        else:
            user.save()
            profile = Profile(user=user, timezone=settings.TIME_ZONE)
            profile.full_clean()
            profile.save()
            messages.success(request, 'New user created!')
            user = authenticate(username=username, password=password)
            dj_login(request, user)
        return redirect('timers')
    else:
        context = AccountContext(request, {})
        return render_to_response('account/new.html', {}, context)
Example #2
0
def login(request):
    if request.user.is_authenticated:
        return redirect('/')
    else:
        if request.method == "POST":
            form = LoginForm(request.POST)
            if form.is_valid():
                username = form.cleaned_data['username']
                password = form.cleaned_data['password']
                remember_me = form.cleaned_data['remember_me']
                user = authenticate(username=username, password=password)
                if user is not None:
                    dj_login(request, user)
                    if not remember_me:
                        request.session.set_expiry(0)
                    return redirect('/')
                else:
                    return render(request, 'login.html', {
                        'form': form,
                        'errors': True
                    })
            else:
                return render(request, 'login.html', {
                    'form': form,
                    'errors': True
                })
        else:
            return render(request, 'login.html', {'form': LoginForm()})
Example #3
0
def login(request):

    if request.method == "POST":
        form = AuthenticationForm(request, data=request.POST)
        username = request.POST.get('username', '')
        password = request.POST.get('password', '')
        if form.is_valid():
            user = auth.authenticate(username=username, password=password)

            if user is not None:
                #dj_login(request, user)
                dj_login(request, user)

                if request.user.is_seller:
                    return redirect('seller:seller-dashboard')
                elif request.user.is_buyer:
                    return redirect('buyer:buyer-dashbooard')

        else:
            args = {'form': form}
            return render(request, 'registration/login.html', args)

    else:
        form = AuthenticationForm

    args = {'form': form}
    return render(request, 'registration/login.html', args)
Example #4
0
def login(request):
    if request.user.is_authenticated:
        return redirect('/dashboard')
    elif request.method == "POST":
        email = request.POST['email']
        password = request.POST['password']
        u = get_object_or_404(User, email=email)
        if u.is_active == False:
            messages.info(
                request,
                "Your Account has not been Verified or Account Deactivated")
            return redirect('/login')
        else:
            user = authenticate(email=email, password=password)
            if user is not None:

                dj_login(request, user)
                request.session.set_expiry(600)
                messages.success(request, f'Welcome to Tradify {u.fullname}')
                return redirect('/dashboard')
            else:
                messages.error(request, "Invalid Details")
                return redirect('/login')
    else:
        return render(request, 'login.html')
Example #5
0
def login_api(request):
    req = request.raw_post_data
    if not req:
        return HttpResponse(
            json.dumps({
                'ok': False,
                'msg': 'No request found',
            }))

    request.session.set_test_cookie()

    try:
        req = json.loads(req)
        form = AuthenticationForm(request, req)
        if form.is_valid():
            dj_login(request, form.get_user())
            return HttpResponse(json.dumps({
                'ok': True,
            }))
    except Exception as e:
        logging.exception(e)

    return HttpResponse(json.dumps({
        'ok': False,
        'msg': 'Login failed',
    }))
Example #6
0
def signup(request):
    if User.is_authenticated:
        dj_logout(request)

    if request.method == 'POST':
        # fill it out with what i need on the way
        context = {}
        # use if not - can easily go out, if it is wrong
        if not request.POST['password'] == request.POST['confirmPassword']:
            #if they dont match, put an error message in the context
            context['error'] = "Passwords do not match."
            # if it is wrong, render the template and send the context
            return render(request, 'loginapp/signup.html', context)
        #check if the list of users is empty or not - use len
        if len(User.objects.filter(username=request.POST['user'])) > 0:
            # if the user already exists, send new error message
            context['error'] = 'Username already exists'
            return render(request, 'loginapp/signup.html', context)

        # create user
        user = User.objects.create_user(request.POST['user'],
                                        password=request.POST['password'])
        user.save()
        dj_login(request, user)
        return HttpResponseRedirect(reverse('blogapp:index'))

    # if it is not a post (then it is a get) it should just show the signup form
    return render(request, 'loginapp/signup.html')
Example #7
0
def connexion(request):
    login_form = LoginForm(request.POST or None)
    if login_form.is_valid():
        username = login_form.cleaned_data.get("username")
        password = login_form.cleaned_data.get("password")
        user = authenticate(request, username=username, password=password)
        if user != None:
            #utilisateur valide et actif(is_active=True)
            #"request.user == user"
            dj_login(request, user)
            group = request.user.groups.filter(user=request.user)[0]
            if group.name == "COOPERATIVES":
                messages.success(request, "Bienvenue : {}".format(username))
                return HttpResponseRedirect(reverse('cooperatives:dashboard'))
            elif group.name == "ADMIN":
                messages.success(request, "Bienvenue : {}".format(username))
                return HttpResponseRedirect(reverse('accueil'))
            elif group.name == "CLIENTS":
                messages.success(request, "Bienvenue : {}".format(username))
                return HttpResponseRedirect(reverse('clients:dashboard'))
            else:
                messages.error(
                    request,
                    "Désolé vous n'estes pas encore enregistrer dans notre Sytème"
                )
                return HttpResponseRedirect(reverse('connexion'))
        else:
            request.session['invalid_user'] = 1  # 1 == True
            messages.error(
                request,
                "Echec de Connexion, Assurez-vous d'avoir entrer le bon login et le bon Mot de Passe SVP !"
            )
            return HttpResponseRedirect(reverse('connexion'))
    return render(request, 'parametres/login.html', {'login_form': login_form})
Example #8
0
def register(request):
    # Creamos el formulario de autenticación vacío

    form = UserCreationForm()

    form.fields['username'].help_text = None
    form.fields['password1'].help_text = None
    form.fields['password2'].help_text = None

    # Si llegamos al final renderizamos el formulario

    if request.method == "POST":
        # Añadimos los datos recibidos al formulario
        form = UserCreationForm(data=request.POST)
        # Si el formulario es válido...
        if form.is_valid():

            # Creamos la nueva cuenta de usuario
            user = form.save()

            # Si el usuario se crea correctamente
            if user is not None:
                # Hacemos el login manualmente
                dj_login(request, user)
                # Y le redireccionamos a la portada
                return redirect('/')

    # Si llegamos al final renderizamos el formulario
    return render(request, "register.html", {'form': form})
Example #9
0
def Login(request):

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

        user_obj = User.objects.filter(username=username).first()
        try:
            vendor = Vendor.objects.get(user=user_obj)
            email = user_obj.email

            if not vendor.is_verified:
                messages.success(
                    request,
                    'Profile is not verified check your mail , we have send the verification link.'
                )
                #creating auth token
                auth_token = str(uuid.uuid4())
                vendor.auth_token = auth_token
                vendor.save()

                #sending mail to the user
                send_mail_after_registration(
                    email,
                    auth_token,
                )
                return redirect('/accounts/login')
        except:
            pass
        user = authenticate(request, username=username, password=password)
        dj_login(request, user)
        return redirect('/')

    return render(request, 'accounts/login.html')
Example #10
0
def register(request):
    form = RegistrationForm()
    if request.method == "POST":
        form = RegistrationForm(request.POST)
        phone = request.POST.get('phone')
        if form.is_valid():
            user_details = form.save()

            #creating cstomer object and add it to customer groups
            Customer.objects.create(
                Phone_no=phone,
                email=user_details.email,
            )
            #adding it to group
            group = Group.objects.get(name='customer')
            user_details.groups.add(group)

            password = request.POST['password1']
            #login
            user = authenticate(request,
                                username=user_details.username,
                                password=password)
            dj_login(request, user)

    context = {'form': form}
    return render(request, 'accounts/register.html', context)
Example #11
0
def login(request):
    error_message = None
    heading = 'Login Form'
    # Creamos el formulario de autenticación vacío
    form = AuthenticationForm()
    if request.method == "POST":
        # Añadimos los datos recibidos al formulario
        form = AuthenticationForm(data=request.POST)
        # Si el formulario es válido...
        if form.is_valid():
            # Recuperamos las credenciales validadas
            username = form.cleaned_data['username']
            password = form.cleaned_data['password']

            # Verificamos las credenciales del usuario
            user = authenticate(username=username, password=password)

            # Si existe un usuario con ese nombre y contraseña
            if user is not None:
                # Hacemos el login manualmente
                dj_login(request, user)
                # Y le redireccionamos a la portada
                return redirect('/')

    # Si llegamos al final renderizamos el formulario
    return render(request, "login.html", {'form': form})
Example #12
0
def authenticate_and_login(request, username, password):
    """takes request username and password and logs user in if has correct credentials"""
    user = authenticate(request, username=username, password=password)
    if user:
        dj_login(request, user)
        return True
    return False
Example #13
0
def login(request):

    error = ""

    if request.method == "POST":
        # Gets users input for each field
        userMail = request.POST.get('inputedEmail')
        userPass = request.POST.get('inputedPassword')
        user = authenticate(request, username=userMail, password=userPass)
        # if there is a user of such then logs them in and renders the home page

        if user is not None:
            dj_login(request, user)
            error = "no"
            return redirect("home")
        # Using elif because when redirecting from /order then message is show cased twice
        # otherwise changes the error var to yes

        elif user is None:
            error = "yes"
            messages.warning(request,
                             "Invalid username or password. Try again.")

    context = {'error': error}

    return render(request, "login.html", context)
Example #14
0
File: views.py Project: alanma/sin
def login_api(request):
  req = request.raw_post_data
  if not req:
    return HttpResponse(json.dumps({
      'ok'   : False,
      'msg'  : 'No request found',
    }))

  request.session.set_test_cookie()

  try:
    req = json.loads(req)
    form = AuthenticationForm(request, req)
    if form.is_valid():
      dj_login(request, form.get_user())
      return HttpResponse(json.dumps({
        'ok'   : True,
      }))
  except Exception as e:
    logging.exception(e)

  return HttpResponse(json.dumps({
    'ok'   : False,
    'msg'  : 'Login failed',
  }))
Example #15
0
def login(request):
    if request.user.is_authenticated:
        return redirect('/dashboard')
    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.objects.filter(pk=user.id, groups__name__in=['Part-time', 'Staff']).exists():
                dj_login(request, user)
                if not request.POST.get('remember', None):
                    # not check remember -> set session time 0
                    request.session.set_expiry(0)
                return redirect('/dashboard')
            else:
                dj_login(request, user)
                if not request.POST.get('remember', None):
                    # not check remember -> set session time 0
                    request.session.set_expiry(0)
                return redirect('/')
                # messages.error(request,
                #                "You don't have permission to access. "
                #                "Please contact your administrator to request access")
        else:
            messages.error(request, 'Wrong account or password. Please try again or click Forgot Password to reset '
                                    'password.')
        return redirect('/login')
    return render(request, 'admin/auth/login.html')
Example #16
0
def join(request):
    form = forms.JoinForm(request.POST)
    if form.is_valid():
        username = form.cleaned_data.get("username")
        password = form.cleaned_data.get("password")
        email = form.cleaned_data.get("email")
        if (User.objects.filter(username=username).exists()
                and User.objects.filter(email=email).exists()):
            messages.error(
                request,
                "Both the username and the email are registered. <a href='/reset-password'>Reset password</a>?",
            )
            return redirect("main:enter")
        if User.objects.filter(username=username).exists():
            messages.error(request, "Username exists. Please try another.")
            return redirect("main:enter")
        if len(email) > 0 and User.objects.filter(email=email).exists():
            messages.error(
                request,
                "This email is connected to an existing account. <a href='/reset-password'>Reset password</a>?",
            )
            return redirect("main:enter")
        user = User(username=username, email=email)
        user.set_password(password)
        user.save()
        user = authenticate(request, username=username, password=password)
        dj_login(request, user)
        messages.success(request, "Welcome to Oscarator!")
        return redirect("main:index")
    else:
        messages.error(request, "Invalid submission. Please try again.")
        return redirect("main:enter")
    return render(request, "main/enter.html")
Example #17
0
 def post(self, request):
     serializer = LoginSerializer(data=request.data)
     serializer.is_valid(raise_exception=True)
     user = serializer.validated_data["user"]
     dj_login(request, user)
     token, created = Token.objects.get_or_create(user=user)
     return Response({'token': token.key}, status=200)
Example #18
0
File: views.py Project: thaingo/sin
def register(request):
  next = request.REQUEST.get('next', reverse('index'))

  if request.user.is_authenticated():
    return HttpResponseRedirect(next)

  if request.method == 'POST':
    form = UserCreationForm(request.POST)
    if form.is_valid():
      user = form.save()
      auth_form = AuthenticationForm(request, {
        'username': request.POST.get('username'),
        'password': request.POST.get('password1'),
      })
      if auth_form.is_valid():  # Should always happen.
        dj_login(request, auth_form.get_user())
      return HttpResponseRedirect(next)
  else:
    request.session.set_test_cookie()
    form = UserCreationForm()

  return render_to_response('register.html', {
    'form': form,
    'next': next,
    }, context_instance=template.RequestContext(request))
Example #19
0
def token_post(request):
    if request.user.is_authenticated:
        messages.error(request, 'You are already logged in.')
        return redirect(settings.LOGIN_REDIRECT_URL)

    if request.GET.get('d'):
        # The user has clicked a login link.
        user = authenticate(token=request.GET['d'])
        if user is not None:
            dj_login(request, user)
            messages.success(request, 'Login successful.')
            return redirect(settings.LOGIN_REDIRECT_URL)
        else:
            messages.error(request, 'The login link was invalid or has expired. Please try to log in again.')
    elif request.method == 'POST':
        # The user has submitted the email form.
        form = EmailForm(request.POST)
        if form.is_valid():
            email_login_link(request, form.cleaned_data['email'])
            messages.success(request, 'Login email sent! Please check your inbox and click on the link.')
        else:
            messages.error(request, 'The email address was invalid. Please check the address and try again.')
    else:
        messages.error(request, 'The login link was invalid or has expired. Please try to log in again.')

    return redirect(settings.LOGIN_URL)
Example #20
0
def invite_verify(request):
    if request.user.is_authenticated:
        messages.error(request, "You are already registered and logged in")
        return redirect(settings.LOGIN_REDIRECT_URL)

    if request.GET.get("d"):
        user = verify_invite_data(token=request.GET["d"])
        if user is not None:
            messages.success(request, "Your account was created succesfully")
            user = authenticate(request, token=request.GET["d"])
            if user is not None:
                dj_login(request, user)
                # billing.subscription_upgrade(request.user)
                return redirect("main:invite_setup")
            else:
                messages.error(
                    request,
                    "The sign in link was invalid or has expired. Please try to sign in again.",
                )
            return redirect(settings.LOGIN_URL)
        else:
            messages.error(request, "Invalid invite")
    else:
        messages.error(request, "Invalid invite")

    return redirect(settings.LOGIN_URL)
 def post(self, request, format=None):
     serializer = PasswordChangeSerializer(data=request.data,\
         context={'request': request})
     if serializer.is_valid():
         old_password = serializer.validated_data['old_password']
         new_password = serializer.validated_data['new_password']
         confirm_password = serializer.validated_data['confirm_password']
         if new_password == confirm_password:
             user_obj = User.objects.get(id=request.user.id)
             user = authenticate(username=user_obj.username,
                                 password=old_password)
             if user:
                 dj_login(request, user)
                 user_obj.password = confirm_password
                 user_obj.save()
                 return Response(
                     {'message': 'password change successfully'},
                     status=200)
             return Response({'message': 'old password do not match'},
                             status=400)
         return Response(
             {
                 'message':
                 'Your new password and confirmation password do not match.'
             },
             status=400)
     return Response({'message': serializer.errors}, status=400)
Example #22
0
def oauth_callback(request):
    osm = OAuth1Session(
        settings.OAUTH_OPENSTREETMAP_KEY,
        client_secret=settings.OAUTH_OPENSTREETMAP_SECRET,
        resource_owner_key=request.session.get("oauth_params")["oauth_token"],
        resource_owner_secret=request.session.get(
            "oauth_params")["oauth_token_secret"],
        verifier='OSMNOPE')
    osm.fetch_access_token('https://www.openstreetmap.org/oauth/access_token')
    userreq = osm.get('https://api.openstreetmap.org/api/0.6/user/details')

    userxml = ET.fromstring(userreq.text)
    userattrs = userxml.find('user').attrib

    try:
        u = User.objects.get(osm_id=userattrs["id"])
    except User.DoesNotExist:
        u = User.objects.create(osm_id=userattrs["id"])
    u.name = userattrs['display_name']
    u.save()

    dj_login(request, u)
    request.session.delete("oauth_params")

    next_redir = request.session.pop('next', None)
    if next_redir:
        return redirect(next_redir)
    return redirect('/login/')
Example #23
0
    def post(self, request):
        ''' Begin reCAPTCHA validation '''
        recaptcha_response = request.POST.get('g-recaptcha-response')
        url = 'https://www.google.com/recaptcha/api/siteverify'
        values = {
            'secret': settings.SERVER_KEY,
            'response': recaptcha_response
        }
        data = urllib.parse.urlencode(values).encode()
        req = urllib.request.Request(url, data=data)
        response = urllib.request.urlopen(req)
        result = json.loads(response.read().decode())
        ''' End reCAPTCHA validation '''

        if result['success']:
            messages.success(request, 'New comment added with success!')
        else:
            return HttpResponse("Captcha Failed... Try again")
        uname = request.POST.get('uname', '')
        password = request.POST.get('psw', '')
        user = authenticate(username=uname, password=password)
        if user is not None:
            if user.is_active:
                dj_login(request, user)  #the user is now logged in
                return HttpResponseRedirect('/splits/postlogin')
        else:
            return HttpResponse("login failed")
Example #24
0
def login(request):
    if not request.user.is_anonymous():
        return HttpResponseRedirect('/admin')

    if request.method == 'POST':
        Aform = AuthenticationForm(request.POST)
        if Aform.is_valid:

            user = request.POST['username']
            passw = request.POST['password']

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

            if access is not None:
                if access.is_active:
                    dj_login(request, access)
                    #Pantalla del Perfil
                    return HttpResponseRedirect('/admin')
                else:
                    error = "Possibly your user is disabled, contact your administrator"
            else:
                error = "Please enter the correct username and password for a staff account. Note that both fields may be case-sensitive."
        else:
            error = "Invalid data"
        ctx = {'Aform': Aform, 'error': error, "username": user}
        return render(request, 'admin/admin-sesion.html', ctx)

    else:
        Aform = AuthenticationForm()

    return render(request, 'admin/admin-sesion.html', {'Aform': Aform})
Example #25
0
def login(request):
    if request.user.is_authenticated:
        return redirect(request.META.get('HTTP_REFERER'))  # already logged in
        messages.add_message(request, messages.INFO, 'Already logged in.')

    if request.method == "POST":
        form = LoginForm(request.POST)
        if form.is_valid():
            username = form.cleaned_data['username']
            password = form.cleaned_data['password']
            user = authenticate(request, username=username, password=password)
            if user is not None:
                dj_login(request, user)
                messages.add_message(request, messages.SUCCESS,
                                     f'Logged in as {user.get_full_name()}')
            else:
                return redirect('login')  # try again
                messages.add_message(request, messages.INFO,
                                     'Failed to authenticate.')
    else:
        form = LoginForm()
    return render(request, 'main/login.html', {
        'form': form,
        'current_user': request.user
    })
Example #26
0
def email_signup(request):
    """
    On POST, create a User and UserProfile for the user, or error. On GET, render the sign up page
    """
    if request.method == "POST":
        email = request.POST.get('email')
        password = request.POST.get('password')
        password_confirm = request.POST.get('password_confirm')

        if not unique_user(email):
            messages.add_message(request, messages.ERROR, 'That email is already registered.')
            return redirect('/accounts/signup')

        if not valid_email_address(email):
            messages.add_message(request, messages.ERROR, 'Invalid email address.')
            return redirect('/accounts/signup')

        valid_pw = check_valid_password(password, password_confirm)
        if not valid_pw:
            messages.add_message(request, messages.ERROR, 'Invalid password.')
            return redirect('/accounts/signup')

        user = User.objects.create_user(username_md5(email), email, password)
        user_profile = UserProfile(user=user)
        user_profile.save()
        auth_user = authenticate(username=username_md5(email), password=password)
        dj_login(request, auth_user)
        return redirect('/subject_preferences')
    else:
        return render(request, 'accounts/signup.html')
Example #27
0
def login(request):
    # context is used to return error messages
    context = {}

    '''
   Check if it's a POST request, if true, it means that the
   form has been filled out and somebody tried to log in
   else, if it is different than a POST request, it means that
   the page has been opened to log in. In that case
   we simply return the login.html file as seen in line 19
    '''
    if request.method == "POST":
        user = authenticate(
            request, username=request.POST["username"], password=request.POST["password"])

        # The user instance returns True or False if the username/password combination if valid.
        if user:
            # Place a session cookie to login the user
            dj_login(request, user)
            return HttpResponseRedirect(reverse('discussion_app:index'))

        # Handle failed login attempts
        else:
            # Update the context dictionary with an error message
            context = {"error_message": "Invalid username/password combination"}

    # Return the login.html page with a context if it exists.
    return render(request, 'account_app/login.html', context)
Example #28
0
def new_account(request):
    """
    This view conducts the act of creating a new account.
    """

    if request.method == "POST":
        new_username = request.POST["new-username"]
        new_password = request.POST["new-password"]
        new_repeat_password = request.POST["new-repeat-password"]
        new_firstname = request.POST["new-firstname"]
        new_lastname = request.POST["new-lastname"]
        new_email = request.POST["new-email"]

        if new_password == new_repeat_password:
            new_user = User.objects.create_user(new_username, new_email,
                                                new_password)
            new_user.first_name = new_firstname
            new_user.last_name = new_lastname
            dj_login(request, new_user)
            new_profile = Profile.objects.create(user=new_user)
            return redirect(reverse("firstfloor:profile_overview"))
        else:
            error_text = "Given passwords do not match."
            return render(request,
                          "firstfloor/new_account.html",
                          context={"error": error_text})
    else:
        return render(request, "firstfloor/new_account.html", context=None)

    new_user = User.objects.create("username", "*****@*****.**", "password")
    new_user.first_name = "firstname"
    new_user.last_name = "lastname"
    new_profile = Profile.objects.create(user=new_user)

    return redirect(reverse("firstfloor:profile_overview"))
Example #29
0
def validate(request, token):
    """validates a token and if it is valid it will
    login the user in"""
    # get the token or 404
    try:
        t = Token.objects.get(token=token)
    except Token.DoesNotExist:
        # sleep for a second to prevent hammering attacks
        sleep(1)
        raise Http404('not matching token could be found')
    # attempt to get the user
    user = authenticate(token=token)
    # if we had a user returned
    if user is not None:
        # if user is active log in and redirect if token next
        if user.is_active:
            # log te user in
            dj_login(request, user)
            # set up redirect
            url = t.next or settings.LOGIN_REDIRECT_URL
            # delete the token
            t.delete()
            # return the redirect
            return HttpResponseRedirect(url)
    # redirect to login
    return HttpResponseRedirect(reverse('zeropass:login'))
Example #30
0
def oauth_callback(request):
    osm = OAuth1Session(
        settings.OAUTH_OPENSTREETMAP_KEY,
        client_secret=settings.OAUTH_OPENSTREETMAP_SECRET,
        resource_owner_key=request.session.get("oauth_params")["oauth_token"],
        resource_owner_secret=request.session.get(
            "oauth_params")["oauth_token_secret"],
        verifier='OSMNOPE')
    osm_attrs = osmuser.get_user_attributes(osm)

    try:
        u = User.objects.get(osm_id=osm_attrs['osm_id'])
    except User.DoesNotExist:
        u = User.objects.create(osm_id=osm_attrs['osm_id'])

    u.name = osm_attrs['display_name']
    u.home_location = osm_attrs.get('home_location', None)
    u.save()

    dj_login(request, u)
    request.session.delete("oauth_params")

    next_redir = request.session.pop('next', None)
    if next_redir:
        return redirect(next_redir)
    return redirect('/login/')
Example #31
0
def register(request):
    if request.method == 'POST' and request.POST:
        form = UserRegisterForm(request.POST)
        if User.objects.filter(email=request.POST['email_address']).count() != 0:
            form.errors['email_address']=['That email is already registered on this database.']
        if len(request.POST['password'])<8:
            form.errors['password']=['Password must be 8 or more characters long.']
        else:
            # Custom error checking ok
            if form.is_valid():
                #do valid stuff
                new_user = User()
                new_user.first_name = form.cleaned_data['first_name']
                new_user.last_name = form.cleaned_data['last_name']
                new_user.email = form.cleaned_data['email_address']
                new_user.set_password(form.cleaned_data['password'])
                new_user.username = base64.b64encode(new_user.email)
                new_user.save()
                user = authenticate(username=new_user.username, password=form.cleaned_data['password'])
                del form.cleaned_data['password']
                dj_login(request, user)
                return redirect('/')
            else:
                pass
    else:
        form = UserRegisterForm()
    return render(request,'frontend_register.html', {'form': form})
Example #32
0
def login(request):
    if request.method == 'GET':
        if request.user.is_authenticated:
            return redirect('LAPTOP')
        else:
            return render(request, "Laptop/login.html")
    else:
        username = request.POST["email"]
        email = username
        password = request.POST["password"]
        try:
            user = User.objects.get(username=username)
            user = authenticate(request, username=username,
                                email=email, password=password)
            if user is not None:
                dj_login(request, user)
                messages.success(request, 'You are logged in.')
                return redirect("LAPTOP")
            else:
                return render(request, "Laptop/login.html", {"error": "Incorrect Password"})
        except User.DoesNotExist:
            user = User.objects.create_user(
                username=username, email=email, password=password)
            user.save()
            dj_login(request, user)
            messages.success(request, 'You are logged in.')
            return redirect('LAPTOP')
Example #33
0
def login(request):
    if request.method == 'POST':
        form = SignIn(request.POST)
        if form.is_valid():
            user = authenticate(request,
                                username=form.cleaned_data.get('pseudo'),
                                password=form.cleaned_data.get('passw'))
            if user is not None:
                dj_login(request, user)
                redirect("home/loginchoice")
            else:
                form = SignIn()
                template = loader.get_template('home/login.html')
                return HttpResponse(
                    template.render(
                        {
                            "form":
                            form,
                            "error":
                            "Erreur dans le couple mot de passe utilisateur"
                        }, request))
            return loginchoice(request)
    else:
        form = SignIn()
        template = loader.get_template('home/login.html')
        return HttpResponse(template.render({"form": form}, request))
Example #34
0
def signup(request):
    if request.method == 'POST':
        # (기본)
        # username = request.POST.get('username')
        # password = request.POST.get('password')
        # (기본)
        form = SignupForm(request.POST, request.FILES)
        # (기본)
        # if username and password:
        # (기본)
        if form.is_valid():
            # 주어진 username의 User가 존재하는지 검사
            # if User.objects.filter(username=username).exists():
            #     return HttpResponse(f'Username {username} is already exist')
            # 없으면 User 생성
            user = form.save()
            # user = form.signup()
            dj_login(request, user)
            return redirect('main')
    else:
        form = SignupForm()
    context = {
        'form': form,
    }
    return render(request, 'member/signup.html', context)

# def user_post(request):
#     post = Post.objects.filter(author=request.user)
Example #35
0
def register(request):
    next = request.REQUEST.get('next', reverse('index'))

    if request.user.is_authenticated():
        return HttpResponseRedirect(next)

    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            auth_form = AuthenticationForm(
                request, {
                    'username': request.POST.get('username'),
                    'password': request.POST.get('password1'),
                })
            if auth_form.is_valid():  # Should always happen.
                dj_login(request, auth_form.get_user())
            return HttpResponseRedirect(next)
    else:
        request.session.set_test_cookie()
        form = UserCreationForm()

    return render_to_response(
        'register.html', {
            'form': form,
            'next': next,
        },
        context_instance=template.RequestContext(request))
Example #36
0
def login(request):
    username = request.POST['username']
    password = request.POST['password']
    user = authenticate(username=username, password=password)
    if user is not None:
        if user.is_active:
            dj_login(request, user)
            return HttpResponse('\'Successful login\'')
        else:
            return HttpResponse('\'Disabled account\'')
    else:
        return HttpResponse('\'Invalid login\'')
Example #37
0
	def login(username,password,request,keepLogin=False):
		user = authenticate(username=username,password=password)
		if user is not None:
			if user.is_active:
				dj_login(request,user)
				#是否保持登录状态
				if keepLogin is False:
					request.session.set_expiry(0)
					request.session.save()
				return MESSAGE.success
			else:
				return MESSAGE.userNotActive
		else:
			return MESSAGE.passwordWrong
Example #38
0
def login(request):
    register_form = RegisterForm()
    if request.method == "POST":
        login_form = LoginForm(request.POST)
        if login_form.is_valid():
            cdata = login_form.cleaned_data
            user = authenticate(email=cdata.get("email"), 
                                password=cdata.get("password"))
            if user:
                dj_login(request, user)
                return HttpResponseRedirect(request.COOKIES.get("next", "/"))
            messages.error(request, _("Wrong email or password "))

    else:
        login_form = LoginForm()
    return render_to_response("auth/login_or_register.jinja", locals())
Example #39
0
def login (request, data):
    singly_id = a.tree_get(data, "account")
    singly_token = a.tree_get(data, "access_token")

    if not singly_id or not singly_token:
        logger.error("Unable to connect user, result from singly: {res}".format(res=data))
    else:
        # Try and find the user associated with this account
        user = a.get_or_none(User, singly_id=singly_id)
        if user is None:

            if not settings.ALLOW_SIGNUP:
                logger.error("Bypassing signup")
                return None

            # Create new user
            logger.debug("Creating new user for {singly_id}".format(singly_id=singly_id))

            # First pull the profile
            profile = combined.get_profile(singly_token)
            username = a.tree_get(profile, "id", lambda d: d[0:30])
            email = a.tree_get(profile, "email")
            first_name, last_name = a.tree_get(profile, "name", lambda n: n.split(" ", 1))

            # Now let's check to see if the email address exists
            user = a.get_or_none(User, email=email)
            if not user:
                # Guess we have to create a new account
                user = User()

                user.first_name = first_name
                user.last_name = last_name
                user.singly_id = singly_id
                user.singly_token = singly_token
                user.username = username
                user.email = email
                if not user.email:
                    user.email = "*****@*****.**"
                user.save()
            else:
                if not combined.merge(singly_token, user.singly_token):
                    return None

        user.backend = "django.contrib.auth.backends.ModelBackend"
        dj_login(request, user)
        return user
Example #40
0
def registration(request):

    if request.method == 'POST':
        form = RegistrationForm(request.POST)
        if form.is_valid():
            User.objects.create_user(form.cleaned_data['username'], 
                                     form.cleaned_data['email'],
                                     form.cleaned_data['password'])
            user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
            dj_login(request, user)

            return HttpResponseRedirect(reverse('landing:index'))
    else:
        form = RegistrationForm()

    return render_response(request, 'landing/registration.html', {
        "form" : form,
    })
Example #41
0
def login(request):
    if request.method == 'GET':
       return render_to_response('dash/pages/page_login.html', {}, context_instance=RequestContext(request))
    elif request.method == 'POST':
        username = request.POST['username']
        print username
        password = request.POST['password']
        print password
        user = authenticate(username=username, password=password)
        if user is not None:
            if user.is_active:
                dj_login(request, user)
                print request.META['HTTP_REFERER']
                return redirect("/") # Redirect to a success page.
            else: # Return a 'disabled account' error message
                return render_to_response('dash/pages/page_login.html', {'message': "disabled account"}, context_instance=RequestContext(request))
        else: # Return an 'invalid login' error message.
            return render_to_response('dash/pages/page_login.html', {'message': 'invalid login'}, context_instance=RequestContext(request))
Example #42
0
File: views.py Project: thaingo/sin
def login(request):
  next = request.REQUEST.get('next', reverse('index'))

  if request.user.is_authenticated():
    return HttpResponseRedirect(next)

  if request.method == 'POST':
    form = AuthenticationForm(request, request.POST)
    if form.is_valid():
      dj_login(request, form.get_user())
      return HttpResponseRedirect(next)
  else:
    request.session.set_test_cookie()
    form = AuthenticationForm(request)

  return render_to_response('login.html', {
    'form': form,
    'next': next,
    }, context_instance=template.RequestContext(request))
Example #43
0
def login(request, template_name='login.html',
          form_class=LoginForm, extra_context=None):
    """用户登录"""
    next_url = request.GET.get('next') or '/'
    form = form_class(data=request.POST or None)
    if form.is_valid():
        username = form.cleaned_data['username']
        password = form.cleaned_data['password']
        user = authenticate(username=username, password=password)
        if user is not None and user.is_active:
            dj_login(request, user)
            return HttpResponseRedirect(next_url)

    context = {
        'form': form,
    }
    if extra_context:
        context.update(context)
    return render_to_response(template_name, context,
                              context_instance=RequestContext(request))
Example #44
0
def login(request):
    next = request.GET.get('next', reverse('home'))
    if request.user.is_authenticated:
        return HttpResponseRedirect(reverse('home'))

    if request.method == 'POST':
        form = SignInForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            user = form.user
            dj_login(request, user)
            next = request.POST.get('next')
            if next == None:
                next = request.GET.get('next', reverse('home'))
            return HttpResponseRedirect(next)
    else:
        form = SignInForm()
    return render(request, 'login2.html', {
        'form': form,
        'next': next,
    })
Example #45
0
def login(request):
    """
    Log the user in on POST or error. On GET, render the login page
    """
    if request.method == "POST":
        email = request.POST.get('email')
        password = request.POST.get('password')

        try:
            temp_user = User.objects.get(username=username_md5(email))
            user = authenticate(username=temp_user.username, password=password)
            if user is not None and user.is_active:
                dj_login(request, user)
                messages.add_message(request, messages.SUCCESS, 'Login successful.')
                return redirect('/accounts/profile/')
            raise ObjectDoesNotExist()
        except ObjectDoesNotExist:
            messages.add_message(request, messages.ERROR, 'Invalid email or password. Try again.')
            return redirect('/accounts/login/')
    else:
        return render(request, 'accounts/login.html')
Example #46
0
def login(request):
    if request.user.is_authenticated():
        return redirect('/')
    errors = None
    if request.method == 'POST' and request.POST:
        form=LoginForm(request.POST)
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(username=username, password=password)
        if user is not None:
            if user.is_active:
                dj_login(request, user)
                return redirect("/")
            else:
                # Return a 'disabled account' error message
                pass
        else:
            errors = 'badauth'
            pass
    else:
        form=LoginForm()
    return render(request,'frontend_login.html', {'form':form, 'errors':errors}, context_instance=RequestContext(request))
Example #47
0
def login(request):
    """
    Log the user in on a POST request. Otherwise, render the login page.
    """
    if request.method == "POST":
        email = request.POST.get('email')
        password = request.POST.get('password')

        try:
            temp_user = User.objects.get(username=email_to_username(email))
            user = authenticate(username=temp_user.username, password=password)
            if user is not None and user.is_active:
                dj_login(request, user)
                return redirect('/dashboard/')
            else:
                raise ObjectDoesNotExist()
        except ObjectDoesNotExist:
            messages.add_message(request, messages.ERROR, 'Unable to log in. Check your email and password.')
            return redirect('/accounts/login/')
    else:
        if request.user.is_authenticated():
            return redirect('/dashboard/')
        return render(request, 'accounts/login.html')
Example #48
0
def login(request):

    if request.method == 'POST':
        form = LoginForm(request.POST)
        if form.is_valid():
            user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
            if user is not None:
                if user.is_active:
                    dj_login(request, user)
                    return HttpResponseRedirect(reverse('landing:index'))
                else:
                    error = _("This account has been disabled.")
            else: 
                error = _("Invalid username and/or password.")
            
            errors = form._errors.setdefault(forms.forms.NON_FIELD_ERRORS, forms.util.ErrorList())
            errors.append(error)
    else:
        form = LoginForm()

    return render_response(request, 'landing/login.html', {
        "form" : form,
    })
Example #49
0
def sign_up(request):
    """
    Create a new user on a POST request (or show an error message if that fails). Otherwise, render the sign up page.
    """
    if request.method == 'POST':
        first_name = request.POST.get('first_name')
        email = request.POST.get('email')
        password = request.POST.get('password')
        password_confirm = request.POST.get('password_confirm')

        if not unique_email(email):
            messages.add_message(request, messages.ERROR, 'That email is already registered.')
            return redirect('/accounts/sign_up/')

        if not valid_email(email):
            messages.add_message(request, messages.ERROR, 'Invalid email address. Please try again.')
            return redirect('/accounts/sign_up/')

        if not valid_password(password, password_confirm):
            messages.add_message(request, messages.ERROR, 'Invalid password. Passwords must be 8 characters or longer '
                                                          'and match.')
            return redirect('/accounts/sign_up/')

        username = email_to_username(email)
        user = User.objects.create_user(username, email, password, first_name=first_name)
        user.save()
        user_profile = UserProfile(user=user)
        user_profile.save()

        auth_user = authenticate(username=username, password=password)
        dj_login(request, auth_user)
        return redirect('/accounts/sign_up_two/')
    else:
        if request.user.is_authenticated():
            return redirect('/dashboard/')
        return render(request, 'accounts/sign_up.html')
Example #50
0
def login(request):
    if request.user.is_authenticated():
        return redirect('timers')
    if request.POST:
        next_url = request.POST.get('next_url')
        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:
                dj_login(request, user)
                if next_url:
                    return redirect(next_url)
                else:
                    return redirect('timers')
            else:
                messages.error(request, 'Your account is inactive.')
        else:
            messages.error(request, 'Invalid login credentials')
        return redirect('home')
    else:
        next_url = request.GET.get('next')
        context = AccountContext(request, {'next_url': next_url})
        return render_to_response('account/login.html', {}, context)
Example #51
0
def login(request, user):
    dj_login(request, user)
    update_membership_by_ip(request.user, request.META['REMOTE_ADDR'])