python类clear()的实例源码

def logout():
    user = User.query.filter_by(username=str(current_user.username)).first()

    user.is_active = False
    db.session.commit()
    session.clear()
    # Clear's chatBox session,
    # this closes the chatBOX

    hriks(
        'Notification: %s Successfully Logged out' % (
            current_user.username
        )
    )

    logout_user()
    # logout_user() is called which will
    # Logout user
    return redirect(url_for('index'))


# When ever this method is chat box will be closed
# and token for the group/user chatting will be
# dropped.

def flush_data():

    if session:
        session.clear()

    encrypted_token = request.args.get('token')

    if not encrypted_token or encrypted_token is None:
        return Response(status=403)

    decrypted_token = decrypt(token=encrypted_token,
                              key_store=current_app.eq['key_store'],
                              key_purpose=KEY_PURPOSE_AUTHENTICATION,
                              leeway=current_app.config['EQ_JWT_LEEWAY_IN_SECONDS'])

    roles = decrypted_token.get('roles')

    if roles and 'flusher' in roles:
        user = _get_user(decrypted_token)
        if _submit_data(user):
            return Response(status=200)
        return Response(status=404)
    return Response(status=403)

def begin_call():
    print "start /begin_call"
    from_number = request.values.get('From', None)
    if from_number in callers:
        session['caller'] = callers[from_number]
    else:
        session['caller'] = "unknown"

    resp = VoiceResponse()
    if session['caller'] != "unknown":
        resp.say("Hey " + session['caller'] + "!")
        gather = Gather(input='dtmf speech', timeout=5, num_digits=4, action='/set_date', method='GET')
        gather.say("Let's record a new "+os.environ['PODCASTNAME']+"!\n First, when will this episode air?\n Say the air date or punch it in using a Month Month Day Day format.\n For example, you could say October 31st or punch in 10 31.")
        resp.append(gather)
        resp.say("You didn't give me a date. Bye!")
    else:
        resp.say("Hey, this isn't for you. \nBoy Bye!")
        resp.hangup()
        session.clear()
    return str(resp)


# validate date & record audio

def save_finish():
    print "start /save_finish"
    resp = VoiceResponse()
    digits = int(request.values.get('Digits', None))
    if digits == 1:
        resp.say("Alright, give me a hot second...")
        # save file to s3 with correct date as filename and end call
        if save_to_s3_url(session['mp3url']+".mp3", session['airdate'].strftime("%Y-%m-%d")+".mp3") is True:
            resp.say("And boom, you're good to go! See you next time " + session['caller'] +" !")
        else:
            resp.say("Yikes "+ session['caller'] + " we ran into an error saving to s3. Can you try calling in again? Sorry!!")
    else:
        resp.say("No problem, just hangup and call back again.")

    resp.hangup()
    session.clear()
    return str(resp)


# process incoming email via mailgun routes (SUPER HACKY!!!)

def get():
    if 'status' in session and session['status'] == 1:
        return "Your coffee is ready but you don't have milk in it.",406
    if 'status' in session and session['status'] == 3:
        if 'milk' not in session or 'syrup' not in session:
            return 'Not acceptable',406
        if session['milk'] != "Half-and-half":
            return "Your coffee is ready but you didn't put the right milk-type.",200
        if session['syrup'] == '':
            return "Your coffee is ready but you didn't put syrup in it.",200
        if session['syrup'] != 'Raspberry':
            return "Your coffee is ready but you didn't put the right syrup-type.",200
        return 'Here is your coffee: INSA{April_Fool_of_Coffee_Machine}',200
    else:
        session.clear()
        return 'Not acceptable',406

def when():
    #Stop pouring milk
    if 'status' not in session or session['status'] != 2:
        session.clear()
        return 'Not acceptable',406

    pouring_duration = (datetime.now() - session['start']).total_seconds()

    if timePouringMilkMin < pouring_duration < timePouringMilkMax:
        session['status'] = 3
        return 'Milk is served.',200
    elif pouring_duration < timePouringMilkMin:
        session.clear()
        return "Not enough milk, try again!",200
    else:
        return "Milk overflow, try again!",200

def _load_user(token) -> typing.Union[UserClass, AnonymousUser]:
    """Loads a user by their token.

    :returns: returns a UserClass instance if logged in, or an AnonymousUser() if not.
    """

    from ..api.utils import authentication

    if not token:
        return AnonymousUser()

    db_user = authentication.validate_this_token(token)
    if not db_user:
        # There is a token, but it's not valid. We should reset the user's session.
        session.clear()
        return AnonymousUser()

    user = UserClass.construct(token, db_user)

    return user

def user_session(func):
    @wraps(func)
    def wrapper(**kwargs):
        from app.models import Utils
        if Utils.getParam(request.args, 'session', default=None):
            user_data = session.get('_user', None)
            if user_data and user_data['is_admin']:
                session.clear()

        user_data = session.get('_user', None)
        kwargs['props'] = {'user': user_data,
                            'cdn': webapp.config['S3_HOST']+'website/',
                            'host': webapp.config['HOST']+'/' 
                          }
        return func(**kwargs)
    return wrapper

def logout():
    """
    Clears the session
    """

    session.clear()

def logout():
    """
    Clears the session
    """

    session.clear()

def logout():
    if authed():
        session.clear()
    return redirect('/')

def logout():
    session.clear()
    return redirect("/")

def logout():
    """
    Clears the session
    """

    session.clear()

def logout():
    session.clear()
    flash('Logged out!', 'success')
    return redirect(url_for('login'))

def aresLogout():
  """ """
  session.clear()
  logout_user()
  return redirect(url_for('ares.aresLogin'))

def build_logout_response(arg_html_text):
    out_response = make_response(arg_html_text)
    out_response.set_cookie(SESSION_COOKIE_NAME, "", expires=0)
    session.clear()
    return out_response

#------------ Web Server Entry Points --------------------------------

# Main entry point (/)
# if in session, stay in session --> main_form
# Else, present login form

def logout(self):
        session.clear()

def logout_user(self):
        session.clear()
        g.user = None
        flash('You are now logged out', 'success')

def logout():
    session.clear()
    return redirect('/?message=logged_out')

def logout():
    session.clear()
    return redirect('/?message=logged_out')

def index():
    session.clear()
    return render_template('index.html')


# 1. dataMangement

def logout():
    # remove the username from the session if it's there
    session.clear()
    return redirect(url_for('index'))

def logout():
    session.clear()
    return redirect('/')

def logout():
    session.clear()
    return redirect("/")

def store_session(metadata):
    """
    Store new session and metadata
    :param metadata: metadata parsed from jwt token
    """
    # clear the session entry in the database
    current_app.eq['session_storage'].delete_session_from_db()

    # also clear the secure cookie data
    session.clear()

    # get the hashed user id for eq
    id_generator = current_app.eq['id_generator']
    user_id = id_generator.generate_id(metadata)
    user_ik = id_generator.generate_ik(metadata)

    # store the user id in the session

    current_app.eq['session_storage'].store_user_id(user_id)
    # store the user ik in the cookie
    current_app.eq['session_storage'].store_user_ik(user_ik)

    questionnaire_store = get_questionnaire_store(user_id, user_ik)
    questionnaire_store.metadata = metadata
    questionnaire_store.add_or_update()
    logger.info('user authenticated')

def logout():
    session.clear()
    return redirect('/')

def logout():
    logout_user()
    session.clear()
    return redirect(url_for('root'))

def remove_if_invalid(response):
    """Remove a stale session and session cookie."""
    if "__invalidate__" in session:
        response.delete_cookie(app.session_cookie_name)
        session.clear()
    return response

def logout():
    """Log out a logged user.

    Note: if the user has logged in via the University of Auckland SSO,
    show the message about the log out procedure and the linke to the instruction
    about SSO at the university.
    """
    org_name = session.get("shib_O")
    try:
        logout_user()
    except Exception as ex:
        app.logger.exception("Failed to log out.")

    session.clear()
    session["__invalidate__"] = True

    if org_name:
        if EXTERNAL_SP:
            sp_url = urlparse(EXTERNAL_SP)
            sso_url_base = sp_url.scheme + "://" + sp_url.netloc
        else:
            sso_url_base = ''
        return redirect(sso_url_base + "/Shibboleth.sso/Logout?return=" + quote(
            url_for(
                "uoa_slo" if org_name and org_name == "University of Auckland" else "login",
                _external=True)))
    return redirect(url_for("login", logout=True))

def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if "logged_in" not in session or not session['logged_in'] \
                or "key" not in session or current_session == None \
                or not current_session.verify_password():
            session.clear()
            return redirect(url_for("login"))
        return f(*args, **kwargs)
    return decorated_function