Python flask_login 模块，login_user() 实例源码

def login():
    """ This login function checks if the username & password
    match the admin.db; if the authentication is successful,
    it passes the id of the user into login_user() """

    if request.method == "POST" and \
       "username" in request.form and \
       "password" in request.form:
        username = request.form["username"]
        password = request.form["password"]

        user = User.get(username)

        # If we found a user based on username then compare that the submitted
        # password matches the password in the database. The password is stored
        # is a slated hash format, so you must hash the password before comparing it.
        if user and hash_pass(password) == user.password:
            login_user(user, remember=True)
            # FIXME! Get this to work properly...
            # return redirect(request.args.get("next") or url_for("index"))
            return redirect(url_for("index"))
        else:
            flash(u"Invalid username, please try again.")
    return render_template("login.html")

def do_ldap_authentication(username, password):
    """Authenticate users with CERT-EU LDAP server

    :param username: CERT-EU email or username
    :param password: Account password
    """
    if '@' in username:
        ldap_user = username.split('@')[0]
    else:
        ldap_user = username
    ldap_info, ldap_authenticated = _ldap_authenticate(ldap_user, password)
    if ldap_authenticated:
        u = User.query.filter_by(
            email=ldap_info['userPrincipalName'][0]).first()
        if not u:
            _save_ldap_user(ldap_info)
            u = User.query.filter_by(
                email=ldap_info['userPrincipalName'][0]).first()
        if login_user(u, remember=True):
            return ApiResponse({'auth': 'authenticated'}, 200)

    raise ApiException('Invalid username or password', 401)

def login():
    if request.method == 'GET':
        return '''
<form action='login' method='POST'>
    <input type='text' name='name' id='name' placeholder='name'></input>
    <input type='password' name='pw' id='pw' placeholder='password'></input>
    <input type='submit' name='submit'></input>
</form>
               '''

    name = request.form.get('name')
    if request.form.get('pw') == password:
        user = User.query.filter_by(name=name).first()
        if not user:
            user = User(name=name)
            db.session.add(user)
            db.session.commit()
        flask_login.login_user(user)
        return redirect(url_for('protected'))

    return 'Bad login'

def login():
    """Render login page for GET requests. Authenticate and redirect to homepage
    for POST requests (if authentication was successful)."""
    if request.method == 'POST':
        username = request.form.get('username', '')
        password = request.form.get('password', '')

        user = user_loader(username)

        if user is not None and user.check_password(password):
            flask_login.login_user(user)
            return redirect(url_for('index'))
        else:
            flash('Invalid login', 'error')

    feide_enabled = secret_settings.OAUTH_CREDENTIALS['id'] != 'ClientID'
    return render_template('login.html', feide_enabled=feide_enabled)

def oauth_callback():
    if flask_login.current_user.is_authenticated:
        return redirect(url_for('index'))
    oauth = DataportenSignin()
    userinfo = oauth.callback()

    if userinfo is None:
        flash('Authentication failed', 'error')
        return redirect(url_for('index'))

    feide_id = userinfo['userid_sec'][0].replace('feide:', '')
    user = database.session.query(User).filter(User.oauth_id == feide_id).first()
    if user is None:
        rand_pass = ''.join(random.choice('abcdefghijklmnopqrstuvwxyz0123456789') for i in range(64))
        database.add_user(feide_id, rand_pass, userinfo['name'], userinfo['email'], False, feide_id)
        database.save_changes()
        user = database.session.query(User).filter(User.oauth_id == feide_id).first()
    flask_login.login_user(user, True)
    return redirect(url_for('index'))

def login():
    if request.method == 'POST':
        if request.form['user'] is '' or request.form['password'] is '':
            flash("Can't leave it blank",'danger')
        else:
            au=auth()
            user=au.check(request.form['user'],request.form['password'])
            if user:
                login_user(user)
                flash('Logged in successfully.','success')
                if user.is_admin:
                        return redirect(url_for('admin'))
                return redirect(url_for('desktops'))
            else:
                flash('Username not found or incorrect password.','warning')
    remote_addr=request.headers['X-Forwarded-For'] if 'X-Forwarded-For' in request.headers else request.remote_addr
    disposables=app.isardapi.show_disposable(remote_addr)
    log.info(disposables)
    log.info(remote_addr)
    return render_template('login_disposables.html', disposables=disposables if disposables else '')

def logout():
    logout_ram_user(current_user.username)
    logout_user()
    return redirect(url_for('index'))

#~ @app.route('/autologin_secret/<secret>/<user>',methods=['GET'])
#~ def autologin(secret,user):
    #~ with app.app_context():
        #~ if r.table('config').get(1).pluck('autologin').run(db.conn)['autologin']['secret'] == secret:
            #~ print('Secret access granted!')

        #~ au=auth()
        #~ user2login=r.table('users').get(user).run(db.conn)
        #~ user=User(user2login)
        #~ if user:
            #~ login_user(user)
            #~ return redirect(url_for('desktops'))
        #~ else:
            #~ return redicrect(url_for('login'))

def login():
    form = ctforge.forms.LoginForm()
    if request.method == 'POST':
        if form.validate_on_submit():
            user = User.get(form.mail.data)
            if user is not None and bcrypt.checkpw(form.password.data, user.password):
                if login_user(user):
                    return redirect(url_for('index'))
                else:
                    flash('Could not log in', 'error')
            flash('Invalid mail or password', 'error')
            return redirect(url_for('login'))
        else:
            flash_errors(form)

    return render_template('login.html', form=form)

def login():

    if flask.request.method == 'GET':
        return render_template('login.html')

    email = request.form['email']
    password = request.form['pass']

    for user in db.session.query(User).filter(User.email == email):
        print('Login Result: ' + user.email, file=sys.stderr)

        if user.check_password(password):
            flask_login.login_user(user)
            return redirect('dashboard')

    return redirect('login_failed')

def register():
    if request.method == 'POST':
        email = request.form['email']
        password = request.form['password']
        phone = flask.request.form['phone']

        if email is not None and password is not None and phone is not None:
            user = User(email, password, phone)
            db.session.add(user)
            db.session.commit()

            flags = Flags(user.id, False, False, False)
            pi = Pi(user.id, datetime.utcnow())

            db.session.add(flags)
            db.session.add(pi)
            db.session.commit()

            flask_login.login_user(user)

            return redirect('dashboard')
        else:
            print('Error creating user: ' + str(email), file=sys.stderr)

    return render_template('register.html')

def login_view(self):
        form = LoginForm(request.form)
        if helpers.validate_form_on_submit(form):
            user = form.get_user()
            if user:
                login.login_user(user)
            else:
                flash('Invalid credentials')

        if login.current_user.is_authenticated:
            return redirect(url_for('.index'))

        # TODO remove HTML code
        link = '<p>Don\'t have an account? <a href="' \
            + url_for('.register_view') + '">Click here to register</a></p>'

        self._template_args['form'] = form
        self._template_args['link'] = link
        return super(AuthenticationView, self).index()

def register_view(self):
        form = RegistrationForm(request.form)
        if helpers.validate_form_on_submit(form):
            user = User()

            form.populate_obj(user)
            user.password = generate_password_hash(form.password.data)

            db.session.add(user)
            db.session.commit()

            login.login_user(user)
            return redirect(url_for('.index'))

        link = '<p>Already have an account? <a href="' \
            + url_for('.login_view') + '">Click here to log in</a></p>'
        self._template_args['form'] = form
        self._template_args['link'] = link
        return super(AuthenticationView, self).index()

def signup():
  if current_user.is_authenticated:
    return redirect(url_for('index'))

  form = SignUpForm(request.form)
  if form.validate_on_submit():

    # Handle duplicate account creation, could be more elegant
    if User.query.filter_by(email=form.email):
      flash('Email already exists, try again', 'warning')
      return redirect(url_for('accounts.signup')) 

    user = User()
    form.populate_obj(user)
    user.createdOn = datetime.datetime.now()
    user.updatedOn = datetime.datetime.now()
    db.session.add(user)
    db.session.commit()
    login_user(user)
    flash('Signed up successfully. Welcome!', 'success')
    return redirect(url_for('index'))

  return render_template('account/signup.html', title = 'Sign Up', form = form)

def login():
  # Already logged in; return to index
  if current_user.is_authenticated:
    return redirect(url_for('index'))

  # Not logged in; show the login form or errors
  form = LoginForm()
  if form.validate_on_submit():
    user = User.query.filter_by(email = form.email.data).first()
    if user is not None and user.valid_password(form.password.data):
      if login_user(user, remember = form.remember.data):
        session.permanent = not form.remember.data
        #Need to add proper message flashing code to base.html
        user.lastLoggedIn = datetime.datetime.now()
        db.session.commit()
        flash('Logged in successfully!', category = 'success')
        return redirect(request.args.get('next') or url_for('index'))
      else:
          flash('This username is disabled', 'danger')
    else:
        flash('Wrong username or password', 'danger')

  return render_template('account/login.html', title = 'Login', form = form)

def login():
    error = 'Login invalido. Por favor, tente novamente.'
    if request.method == 'GET':
        return render_template("home.html", erro=error)
    else:
        try:
            femail = request.form['username']
            fsenha = request.form['password']
            pessoa = Registro.query.filter_by(email=femail).first()

            if pessoa.password == fsenha:
                user = User()
                user.id = femail
                user.pessoa = pessoa
                flask_login.login_user(user)
                if user.pessoa.person == 2:
                    return redirect(url_for('telaPrincipal'))
                elif user.pessoa.person == 1:
                    return redirect(url_for('ideiasteste'))
        except:
            return render_template("home.html", erro=error)

    return render_template("home.html", erro=error)

def home():
    """
    web login
    :return:
    """
    if flask.request.method == 'POST':
        email = flask.request.form['email']
        password = flask.request.form['password']
        user = User.query.filter_by(email=email).first()
        if user is not None:
            if user.password == password:
                flask_login.login_user(user)
                return flask.redirect("/admin")
            else:
                return "Wrong Password"
        else:
            return "Wrong Username"
    else:
        return flask.render_template("login.html")

def login():
    if flask.request.method == 'GET':
        return flask.render_template("login.html", curid = 0)
    email = flask.request.form['email']
    print("IN /LOGIN: THIS IS THE email RESULT:", str(email))
    cur.execute("""SELECT hashpswd, sid, validated from students where email = %s;""", (email,))
    lst = cur.fetchall()
    conn.commit()
    if len(lst) != 0:
        print("IN /LOGIN: THIS IS lst RESULT:", str(lst))
        if not lst[0][2]:
            return "You must validate your account first!"
        print("IN /LOGIN: THIS IS check_password_hash RESULT:", str(check_password_hash(lst[0][0], flask.request.form['pw'])))
        if check_password_hash(lst[0][0], flask.request.form['pw']):
            user = User()
            user.id = lst[0][1]
            flask_login.login_user(user)
            return flask.redirect(flask.url_for('student_games'))
    return 'Bad login'

#==========================# STUDENT PROTECTED VIEW #==========================#

def loginProfessor():
    email = flask.request.args['email']
    password = flask.request.args['pw']
    cur.execute("""SELECT hashpswd from professor where email = %s;""", (email,))
    lst = cur.fetchall()
    conn.commit()
    # Check password to hashed pass in table
    if len(lst) == 0:
        return "Professor account not created. Please create an account first."
    if check_password_hash(lst[0][0], password):
        cur.execute("""SELECT pid from professor where email = %s;""", (email,))
        mylst = cur.fetchall()
        conn.commit()
        pid = mylst[0][0]
        user = User()
        user.id = pid
        flask_login.login_user(user)
        return flask.redirect(flask.url_for('admin_dashboard'))
    if not check_password_hash(lst[0][0], password):
        return "Password is wrong. Shame on you."
    return "Some error -- Contact Webmaster"

def create_session(user):
    """
    Create the login session 
    :param user: UserModel
    :return:
    """

    def cb():
        if user:
            if __options__.get("require_email_verification") and not user.email_verified:
                raise exceptions.VerifyEmailError()
            if flask_login.login_user(user):
                user.update(last_login_at=utc_now())
                return user
        return None

    return signals.user_login(cb)


#

def login():
    if is_logged_in():
        return redirect(url_for('dashboard.DashboardView'))

    form = LoginForm(request.form)
    if request.method == 'POST' and form.validate():
        user = User.query.filter_by(username=form.username.data).first()
        if user:
            if sha256_crypt.verify(form.password.data, user.password):
                flask_login.login_user(user, remember=True)
                return redirect(url_for('dashboard.DashboardView'))
        flask.flash('Sorry, that username/password combination was incorrect.')
    return render_template('other/login.html', title='Login', form=form)

def login(user_account):
    """Login desired user into the app

    :param user_account: User account to be logged in
    :type user_account: ``repocribro.models.UserAccount``
    """
    flask_login.login_user(user_account)
    flask_principal.identity_changed.send(
        flask_principal.current_app._get_current_object(),
        identity=flask_principal.Identity(user_account.id)
    )

def get_sign_in_view(target):
    signin_url = request.url_root + target
    oauth_service = OAuth2Service(
        name="google",
        client_id=current_app.config["GOOGLE_LOGIN_CLIENT_ID"],
        client_secret=current_app.config["GOOGLE_LOGIN_CLIENT_SECRET"],
        authorize_url=google_params.get("authorization_endpoint"),
        base_url=google_params.get("userinfo_endpoint"),
        access_token_url=google_params.get("token_endpoint"))

    if "code" in request.args:
        oauth_session = oauth_service.get_auth_session(
            data={"code": request.args["code"],
                  "grant_type": "authorization_code",
                  "redirect_uri": signin_url},
            decoder=json.loads)
        user_data = oauth_session.get("").json()
        user = load_user(user_data["email"])
        if user:
            flask_login.login_user(user)
            return redirect(url_for("index"))
        else:
            error_message = "Not an authorized user ({})".format(user_data["email"])
            return render_template("/sign_in.html", error_message=error_message)
    elif "authorize" in request.args:
        return redirect(oauth_service.get_authorize_url(
            scope="email",
            response_type="code",
            prompt="select_account",
            redirect_uri=signin_url))
    else:
        return render_template("/sign_in.html")

def signin_user_db(user_db):
  if not user_db:
    return flask.redirect(flask.url_for('signin'))
  flask_user_db = FlaskUser(user_db)
  auth_params = flask.session.get('auth-params', {
    'next': flask.url_for('welcome'),
    'remember': False,
  })
  flask.session.pop('auth-params', None)
  if flask_login.login_user(flask_user_db, remember=auth_params['remember']):
    user_db.put_async()
    return flask.redirect(util.get_next_url(auth_params['next']))
  flask.flash('Sorry, but you could not sign in.', category='danger')
  return flask.redirect(flask.url_for('signin'))

def login(self, request, session=None):
    if current_user.is_authenticated():
        flash("You are already logged in")
        return redirect(url_for('index'))

    username = None
    password = None

    form = LoginForm(request.form)

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

    if not username or not password:
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

    try:
        KerberosUser.authenticate(username, password)

        user = session.query(models.User).filter(
            models.User.username == username).first()

        if not user:
            user = models.User(
                username=username,
                is_superuser=False)

        session.merge(user)
        session.commit()
        flask_login.login_user(KerberosUser(user))
        session.commit()

        return redirect(request.args.get("next") or url_for("admin.index"))
    except AuthenticationError:
        flash("Incorrect login details")
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

def login(self, request, session=None):
    if current_user.is_authenticated():
        flash("You are already logged in")
        return redirect(url_for('admin.index'))

    username = None
    password = None

    form = LoginForm(request.form)

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

    if not username or not password:
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

    try:
        user = session.query(PasswordUser).filter(
            PasswordUser.username == username).first()

        if not user:
            session.close()
            raise AuthenticationError()

        if not user.authenticate(password):
            session.close()
            raise AuthenticationError()
        log.info("User %s successfully authenticated", username)

        flask_login.login_user(user)
        session.commit()

        return redirect(request.args.get("next") or url_for("admin.index"))
    except AuthenticationError:
        flash("Incorrect login details")
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

def login(self, request, session=None):
    user = session.query(models.User).filter(
        models.User.username == DEFAULT_USERNAME).first()
    if not user:
        user = models.User(
            username=DEFAULT_USERNAME,
            is_superuser=True)
    session.merge(user)
    session.commit()
    flask_login.login_user(DefaultUser(user))
    session.commit()
    return redirect(request.args.get("next") or url_for("index"))

def login():
    #This checks for the username in the 'database'.
    if request.method == 'GET':
        if current_user.is_authenticated:
            return flask.redirect(flask.url_for('frosti'))
        return render_template('login.html')

    username = request.form['username']
    password = request.form['password']
    rememberme = False
    if 'rememberme' in request.form:
        rememberme = True

    dbResult = User.get(username)
    if dbResult is not None:
    #Yep, so we send login_user a user, AND the user_loader thing also makes one.
        user = User(dbResult[0],dbResult[1])
        if password == user.password:
            login_user(user, remember = rememberme)
            flash('Login Successful')
            next = flask.request.args.get('next')
            return flask.redirect(flask.url_for('hello'))

    error = 'Incorrect username or password'
    return render_template('login.html',error=error)

def classroom_test():
    #~ if request.method == 'POST':
        #~ None
    #~ users=app.isardapi.get_group_users('hisx1',['id','name','username'])
    #~ print(len(users))
    #~ print(len(users)/6)
    #~ print(int(len(users)/6) + (len(users) % 6 > 0))
    #~ host = {
           #~ 'hostname'   : 'n2m05',
           #~ 'place_id'   : 'n2m',
           #~ 'ip'         : '10.200.212.201',
           #~ 'description': 'n2m 05',
           #~ 'mac'        : '01:02:03:04:05:06',
           #~ 'enable'     : True,
           #~ 'status'     : 'Offline', #Offline, online, ready_to_launch_ssh_commands
           #~ 'login_user' : None,
           #~ 'desktops_running':[],
           #~ 'online_date': '2017/05/05 13:23:04'}

    #~ hosts={}
    #~ i=0
    #~ for r in range(0,int(len(users)/6) + (len(users) % 6 > 0)):
        #~ hosts[r]={}
        #~ for c in range(0,6):
            #~ print(str(i)+' '+str(len(users)))
            #~ if i == len(users): break
            #~ hosts[r][c]={'status':random.randrange(0,3),'ip':users[i]['id'],'hostname':users[i]['name']}
            #~ i=i+1


    #~ for r in range(0,6):
        #~ hosts[r]={}
        #~ for c in range(0,random.randrange(4,8)):
            #~ hosts[r][c]={'status':random.randrange(0,3),'ip':'10.200.210.'+str(r+c),'hostname':'f2a-'+str(r+c)}
    items=app.isardapi.get_hosts_viewers('PROVA1')
    return render_template('pages/classroom_test.html', nav='Classroom', hosts=hosts)

def login():
    form=LoginForm()
    openid_from=OpenIDFrom()

    # Send the request for login to relay party(URL)
    if openid_from.validate_on_submit():
        return openid.try_login(
            openid_from.openid_url.data,
            ask_for=['nickname','email'],
            ask_for_optional=['fullname']
        )
    # Try to login the relay party failed.
    openid_errors=openid.fetch_error()
    if openid_errors:
        flash(openid_errors,category='danger')

    if form.validate_on_submit():

        user=User.query.filter_by(username=form.username.data).one()
        #login_user() ????????? load_user() ?????? User ??,
        # ??? session ?, ???????????????????????.
        # ???????????????, ???? login_user()??? remember ?? True ??????.
        login_user(user,remember=form.remember.data)

        identity_changed.send(
            current_app._get_current_object(),
            identity=Identity(user.id))

        flash("You have been logger in",category='success')
        return redirect(url_for('blog.home'))

    return render_template('login.html',form=form,
                           openid_from=openid_from)

def login():
    if g.user is not None and g.user.is_authenticated:
        return redirect(url_for('index'))

    form = LoginForm()

    if request.method == 'POST':
        if form.validate_on_submit():
            formusername = form.username.data
            password = form.password.data
            user = User.query.filter_by(username=formusername).first()

            if (user is None) or (password is None):
                flash('Failed validation', 'error')
            else:
                if user.check_password(password):
                    flask_login.login_user(user)
                    return redirect(url_for('index'))
                else:
                    flash(responds['FAILED_VALIDATION'], 'error')
        else:
            flash(responds['FAILED_VALIDATION'], 'error')

    return render_template('login.html',
                           title='Sign In',
                           form=form
                           )

def login_view(self):
        # handle user login
        form = LoginForm(request.form)

        if request.method == 'POST':
            if helpers.validate_form_on_submit(form) and form.validate_login():
                user = form.get_user()
                login.login_user(user)
                return redirect(url_for('admin.index'))

        self._template_args['form'] = form
        return super(MyAdminIndexView, self).index()

def login(home: str=None, login: str=None) -> str:
    """Login using Google authentication.

    :param home: URL for queue homepage
    :param login: URL for queue login page
    """
    try:
        flow = get_google_auth_flow(login)
        if 'code' not in request.args:
            return redirect(get_google_authorize_uri(flow))
        person = get_google_person(flow)
        user = User.query.filter_by(google_id=person['id']).first()
        if not user:
            user = User(
                name=person['displayName'],
                email=person['emails'][0]['value'],
                google_id=person['id'],
                image_url=person['image']['url']).save()
        flask_login.login_user(user)
        return redirect(home or url_for('public.home'))
    except client.FlowExchangeError:
        return redirect(login or url_for('public.login'))


######################
# SESSION UTILIITIES #
######################

def login(self, request):
    session = settings.Session()
    user = session.query(models.User).filter(
        models.User.username == DEFAULT_USERNAME).first()
    if not user:
        user = models.User(
            username=DEFAULT_USERNAME,
            is_superuser=True)
    session.merge(user)
    session.commit()
    flask_login.login_user(DefaultUser(user))
    session.commit()
    session.close()
    return redirect(request.args.get("next") or url_for("index"))

def login_user(oauth_token: str, *, load_from_db=False):
    """Log in the user identified by the given token."""

    if load_from_db:
        user = _load_user(oauth_token)
    else:
        user = UserClass(oauth_token)
    flask_login.login_user(user, remember=True)
    g.current_user = user

def login_user(user, remember=None):
    """Performs the login routine.

    :param user: The user to login
    :param remember: Flag specifying if the remember cookie should be set. Defaults to ``False``
    """

    if remember is None:
        remember = config_value('DEFAULT_REMEMBER_ME')

    if not _login_user(user, remember):  # pragma: no cover
        return False

    if _security.trackable:
        if 'X-Forwarded-For' in request.headers:
            remote_addr = request.headers.getlist("X-Forwarded-For")[0].rpartition(' ')[-1]
        else:
            remote_addr = request.remote_addr or 'untrackable'

        old_current_login, new_current_login = user.current_login_at, datetime.utcnow()
        old_current_ip, new_current_ip = user.current_login_ip, remote_addr

        user.last_login_at = old_current_login or new_current_login
        user.current_login_at = new_current_login
        user.last_login_ip = old_current_ip or new_current_ip
        user.current_login_ip = new_current_ip
        user.login_count = user.login_count + 1 if user.login_count else 1

        _datastore.put(user)

    identity_changed.send(current_app._get_current_object(),
                          identity=Identity(user.id))
    return True

def login_view(self):
        form = LoginForm(request.form)

        if helpers.validate_form_on_submit(form):
            user = form.get_user()
            login.login_user(user)

        if isAdmin():
            return redirect(url_for('.index'))

        self._template_args['form'] = form
        return super(MyAdminIndexView, self).index()

def signin_user_db(user_db, remember=False):
    """Signs in given user"""
    flask_user_db = FlaskUser(user_db)
    auth_params = flask.session.get('auth-params', {
        'remember': remember,
    })
    flask.session.pop('auth-params', None)
    return login.login_user(flask_user_db, remember=auth_params['remember'])

def email_login():
    """
    login check
    :return:
    """
    if flask.request.method == 'POST':
        content = flask.request.form.get("html")
        if content is not None:
            print(content)
            soup = BeautifulSoup(content, "html.parser")
            save_key = soup.find(id="save_key").text.strip()
            # session_id will expire after 24 hours
            session_id = save_signer.unsign(save_key, max_age=86400)
            session_id = bytes.decode(session_id)
            user = User.query.filter_by(session_id=session_id).first_or_404()
            # try to save the attachment file
            limit_counter = 0
            try:
                for attachment in flask.request.files:
                    if limit_counter >= 1:
                        break
                    file_name = str(uuid.uuid1()) + guess_extension(flask.request.files[attachment].mimetype)
                    flask.request.files[attachment].save(file_name)
                    flask.session["file_name"] = file_name
                    limit_counter += 1
            except AttributeError:
                flask.session["file_name"] = ""
            flask.session["entry"] = soup.select('div[style]')[0].text
            flask.session["user_real_id"] = user.user_id
            # after login flask_login will push user_id into session and this user_id is our session_id
            # as the get_id method in User model returns user's session id
            flask_login.login_user(user)
            return flask.redirect(flask.url_for('protected_save'))
    return flask.redirect(flask.url_for('protected_save'))

def login():
    if request.method == 'GET':
        return render_template('signin.html')
    auth = authorize(request.form['email'])
    if auth and hashlib.md5(request.form['pw'].encode()).hexdigest() == auth['passhash']:
        user = User()
        user.id = auth['email']
        user.name = "%s %s" % (auth['firstname'], auth['lastname'])
        user.i_user = auth['i_user']
        user.is_admin = int(auth['role']) == 1
        flask_login.login_user(user, remember=True)
        return render_template('index.html')
    return render_template('error.html', message = 'Unauthorized')

def index():
    return render_template('index.html', curid = 0)

# @app.route('/login', methods=['GET', 'POST'])
# def login():
#     if flask.request.method == 'GET':
#         return render_template('login.html', curid = 0)
#     email = flask.request.form['email']
#     print("IN /LOGIN: THIS IS THE email RESULT:", str(email))
#
#     cur.execute("""SELECT hashpswd, sid from students where email = %s;""", (email,))
#     lst = cur.fetchall()
#     if len(lst) != 0:
#         print("IN /LOGIN: THIS IS lst RESULT:", str(lst))
#         conn.commit()
#         print("IN /LOGIN: THIS IS check_password_hash RESULT:", str(check_password_hash(lst[0][0], flask.request.form['pw'])))
#         if check_password_hash(lst[0][0], flask.request.form['pw']):
#             user = User()
#             user.id = lst[0][1]
#             flask_login.login_user(user)
#             return flask.redirect(flask.url_for('protected'))
#     return 'Bad login'
#
# @app.route('/protected')
# @flask_login.login_required
# def protected():
#     return 'Logged in as: ' + flask_login.current_user.id

def login():
    form = forms.LoginForm()
    if form.validate_on_submit():
        user = models.User.login(form.email.data, form.pw.data)
        if user:
            flask_login.login_user(user)
            endpoint = flask.request.args.get('next', '.index')
            return flask.redirect(flask.url_for(endpoint)
                or flask.url_for('.index'))
        else:
            flask.flash('Wrong e-mail or password', 'error')
    return flask.render_template('login.html', form=form)

def with_username(username, password):
    """
    To authenticate a user with user and password
    *** authenticate doesn't create a session. To create a session, 
    use login_user
    :param username: 
    :param password: 
    :return: UserModel
    """
    user = models.AuthUser.get_by_username(username)
    return _user(user) if user and user.password_matched(password) else None

def login_user(user):
    # Deprecated
    return create_session(user)

def login_view(self):
        # handle user login
        form = AdminLoginForm(request.form)

        if helpers.validate_form_on_submit(form):
            user = get_user(form)
            login.login_user(user)

        if login.current_user.is_authenticated:
            return redirect(url_for('.index'))

        self._template_args['form'] = form
        return super(MyAdminIndexView, self).index()

def login(self, request, session=None):
    if current_user.is_authenticated():
        flash("You are already logged in")
        return redirect(url_for('admin.index'))

    username = None
    password = None

    form = LoginForm(request.form)

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

    if not username or not password:
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

    try:
        LdapUser.try_login(username, password)
        log.info("User %s successfully authenticated", username)

        user = session.query(models.User).filter(
            models.User.username == username).first()

        if not user:
            user = models.User(
                username=username,
                is_superuser=False)

        session.merge(user)
        session.commit()
        flask_login.login_user(LdapUser(user))
        session.commit()

        return redirect(request.args.get("next") or url_for("admin.index"))
    except (LdapException, AuthenticationError) as e:
        if type(e) == LdapException:
            flash(e, "error")
        else:
            flash("Incorrect login details")
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

def login(self, request):
    if current_user.is_authenticated():
        flash("You are already logged in")
        return redirect(url_for('index'))

    username = None
    password = None

    form = LoginForm(request.form)

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

    if not username or not password:
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

    try:
        KerberosUser.authenticate(username, password)

        session = settings.Session()
        user = session.query(models.User).filter(
            models.User.username == username).first()

        if not user:
            user = models.User(
                username=username,
                is_superuser=False)

        session.merge(user)
        session.commit()
        flask_login.login_user(KerberosUser(user))
        session.commit()
        session.close()

        return redirect(request.args.get("next") or url_for("admin.index"))
    except AuthenticationError:
        flash("Incorrect login details")
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

def login(self, request):
    if current_user.is_authenticated():
        flash("You are already logged in")
        return redirect(url_for('admin.index'))

    username = None
    password = None

    form = LoginForm(request.form)

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

    if not username or not password:
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

    try:
        session = settings.Session()
        user = session.query(PasswordUser).filter(
            PasswordUser.username == username).first()

        if not user:
            session.close()
            raise AuthenticationError()

        if not user.authenticate(password):
            session.close()
            raise AuthenticationError()
        LOG.info("User %s successfully authenticated", username)

        flask_login.login_user(user)
        session.commit()
        session.close()

        return redirect(request.args.get("next") or url_for("admin.index"))
    except AuthenticationError:
        flash("Incorrect login details")
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

def login(self, request):
    if current_user.is_authenticated():
        flash("You are already logged in")
        return redirect(url_for('admin.index'))

    username = None
    password = None

    form = LoginForm(request.form)

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

    if not username or not password:
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)

    try:
        LdapUser.try_login(username, password)
        LOG.info("User %s successfully authenticated", username)

        session = settings.Session()
        user = session.query(models.User).filter(
            models.User.username == username).first()

        if not user:
            user = models.User(
                username=username,
                is_superuser=False)

        session.merge(user)
        session.commit()
        flask_login.login_user(LdapUser(user))
        session.commit()
        session.close()

        return redirect(request.args.get("next") or url_for("admin.index"))
    except (LdapException, AuthenticationError) as e:
        if type(e) == LdapException:
            flash(e, "error")
        else:
            flash("Incorrect login details")
        return self.render('airflow/login.html',
                           title="Airflow - Login",
                           form=form)