Python Response.set_cookie方法代码示例

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
def cookie_app(environ, start_response):
    """A WSGI application which sets a cookie, and returns as a response any
    cookie which exists.
    """
    response = Response(environ.get("HTTP_COOKIE", "No Cookie"), mimetype="text/plain")
    response.set_cookie("test", "test")
    return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
    def __call__(self, environ, start_response):
        request = Request(environ)
        response = Response('')
        self._get_session(request)
        request_method = environ['REQUEST_METHOD']
        form = parse_form_data(environ)[1]
        path = environ.get('PATH_INFO','')
        request_url = request.url
        params = request.args
        resp = self._process_request(request_method, request_url, path, params, form)
        logging.debug(str(resp))
        if resp:
            if 'set_values' in resp:
                self._set_values(environ)
                return self._application(environ, start_response)
            if 'ignore_callback' in resp and resp['ignore_callback'] == True:
                  return self._ignored_callback(environ, start_response)

            if 'status' in resp:
                response.status = resp['status']
            for name in ['Location', 'Content-Type', 'WWW-Authenticate']:
                if name in resp['headers']:
                    response.headers[name] = resp['headers'][name]
            if 'data' in resp:
                response.data = resp['data']
            response.set_cookie(self.CAS_COOKIE_NAME, value = self._session.sid, max_age = None, expires = None)
            return response(environ, start_response)
        else:
            return self._application(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
 def index(self, request):
     # werkzeug have a low level session support,
     # you need send session id to browser cookie manually
     sid = request.cookies.get(self.COOKIE_NAME)
     if sid is None:
         # don't have a session id, create new session
         request.session = session_store.new()
     else:
         request.session = session_store.get_session(sid)
     if self.LUCKY_NUM_KEY in request.session:
         lucky_num = request.session[self.LUCKY_NUM_KEY]
     else:
         # random a new lucky number,
         # then store it in session
         # when user access again, will use the same lucky number
         lucky_num = random.randint(1, 10)
         request.session[self.LUCKY_NUM_KEY] = lucky_num
     response = Response('Hello, your lucky number is: %s' % (lucky_num,))
     if sid is None:
         # if the user don't have a session id,
         # don't forgot send session id to cookie
         response.set_cookie(self.COOKIE_NAME, request.session.sid)
     # and you should save session manually
     if request.session.should_save:
         session_store.set(request.session.sid, dict(request.session))
     return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
def fake_login(request):
    if request.method == 'GET':
        return Response("FAKE LOGIN", mimetype="text/html")
    elif request.method == 'POST':
        response = Response("LOGGED IN", mimetype="text/html")
        cookie = SecureCookie({"logged_in": True}, SECRET_KEY)
        response.set_cookie('session_data', cookie.serialize())
        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
def cookie_app(environ, start_response):
    """A WSGI application which sets a cookie, and returns as a ersponse any
    cookie which exists.
    """
    response = Response(environ.get('HTTP_COOKIE', 'No Cookie'),
                        mimetype='text/plain')
    response.set_cookie('test', 'test')
    return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
def insertFacebookUser(request):
    from MySQLSessionStore import MySQLSessionStore
    session_store = MySQLSessionStore()

    token = request.form.get('token')

    print request.form

    fid = face.valid_face(token)
    if not fid:
        return

    sid = request.form.get('sid')
    fname = request.form.get('fname')
    sname = request.form.get('sname')
    lon = request.form.get('lon')
    lat = request.form.get('lat')
    starting_year = request.form.get('starting_year')
    car = request.form.get('car')
    if car == 'true':
        car = True
    else:
        car = False

    #sqlusr = "insert into user (study_id, firstname, surname, latlon,starting_year, car) values(" + sid + "," + "\"" + fname + "\"," + "\"" + sname + "\",point(" + lat + "," + lon + ")," + starting_year + "," + car + ")"
    sqlusr = "insert into user (study_id, firstname, surname, latlon,starting_year, car) values(%s,%s,%s, point(%s,%s), %s, %s)"

    #sqlfb = "insert into facebook_user values((select user_id from user where firstname=\"" + fname + "\" and surname=\""  + sname +  "\"), \"" + fbid + "\")"
    sqlfb = "insert into facebook_user values(%s, %s)"

    db = sql.getdb()

    success = False

    try:
        cursor = db.cursor()
        cursor.execute(sqlusr, (sid, fname, sname, lat, lon, starting_year,car ))
        user_id = cursor.lastrowid
        print user_id
        print fid
        cursor.execute(sqlfb, (user_id, fid))
        db.commit()
        success = True
    except Exception as ex:
        print ex
        db.rollback()       
        success = False

    if success:
        user_id = session_store.get_userid_from_face(fid)

        import datetime
        request.session = session_store.session_new("",user_id)
        response = Response("",mimetype='text/plain')
        response.set_cookie('hccook', value=request.session.sid, max_age=3600*24*4, expires=datetime.datetime.utcnow() + datetime.timedelta(days=4))
        return response
    else:
        return Response('{test:"test"}')

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
def login_success(user_id,sid=None,send_cookie=False):
    ##log.debug("Login success")
    c = collections.OrderedDict()
    ar = []

    c['user_id'] = user_id
    ar.append(c)
    response = Response(json.dumps(ar), mimetype='text/plain')
    if send_cookie:
        import datetime
        response.set_cookie('hccook', value=sid, max_age=3600*24*4, expires=datetime.datetime.utcnow() + datetime.timedelta(days=4))
    return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
def fbUserId(request):
    import face
    from MySQLSessionStore import MySQLSessionStore

    session_store = MySQLSessionStore()

    cursor = sql.getCursor()
    token = request.args.get('token')

    fid = face.valid_face(token)
    if fid == None:
        return Response('[{"user_id":-200}]', mimetype='text/plain')


    user_id = session_store.get_userid_from_face(fid)
    if not user_id:
        response = Response('[{"user_id": -100, "study_id": null, "firstname": "null", "surname": "null", "latlon": "null", "institution_name": "null", "campus_name": "null", "department_name": "null", "name_of_study": "null", "starting_year": null, "car": null, "gcm_id":null}]',mimetype='text/plain')
        return response

    rowarray = []
    cursor.execute("SELECT user_id, user.study_id, firstname, surname, AsText(latlon) as latlon, institution.institution_name, campus.campus_name, department.department_name, name_of_study, starting_year, car, gcm_id FROM user INNER JOIN study ON user.study_id = study.study_id INNER JOIN campus ON study.campus_id = campus.campus_id ""INNER JOIN department ON study.department_id = department.department_id INNER JOIN institution ON department.institution_id = institution.institution_id WHERE user_id = (SELECT user_id FROM facebook_user WHERE facebook_id=%s)",(fid))
    rows = cursor.fetchall()

    for row in rows:
        c = collections.OrderedDict()
        c['user_id'] = row[0]
        c['study_id'] = row[1]
        c['firstname'] = str(row[2])
        c['surname'] = str(row[3])
        c['latlon'] = str(row[4])
        c['institution_name'] = str(row[5])
        c['campus_name'] = str(row[6])
        c['department_name'] = str(row[7])
        c['name_of_study'] = str(row[8])
        c['starting_year'] = row[9]
        c['car'] = row[10]
        c['gcm_id'] = row[11]
        rowarray.append(c)

    j = json.dumps(rowarray, ensure_ascii=False)
    response = Response(j, mimetype='text/plain')

    sid = request.cookies.get('hccook')

    if not (sid and  session_store.session_valid(sid)):
        import datetime
        request.session = session_store.session_new("",user_id)
        response.set_cookie('hccook', value=request.session.sid, max_age=3600*24*4, expires=datetime.datetime.utcnow() + datetime.timedelta(days=4))

    return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
    def __call__(self, environ, start_response):
        """
        Works as specified by the WSGI
        """
        ui_lang = get_lang(environ)
        translation.activate(ui_lang)
        l10n.activate(ui_lang)
        environ['REQUEST_URI'] = wsgiref.util.request_uri(environ)  # TODO remove?

        sessions = plugins.get('sessions')
        request = Request(environ)
        sid = request.cookies.get(sessions.get_cookie_name())
        if sid is None:
            request.session = sessions.new()
        else:
            request.session = sessions.get(sid)

        sid_is_valid = True
        if environ['PATH_INFO'] in ('/', ''):
            url = environ['REQUEST_URI']
            if not url.endswith('/'):
                url += '/'
            status = '303 See Other'
            headers = [('Location', '%sfirst_form' % url)]
            body = ''
        elif '/run.cgi/' in environ['REQUEST_URI']:  # old-style (CGI version) URLs are redirected to new ones
            status = '301 Moved Permanently'
            headers = [('Location', environ['REQUEST_URI'].replace('/run.cgi/', '/'))]
            body = ''
        else:
            controller_class = load_controller_class(environ['PATH_INFO'])
            app = controller_class(request=request, ui_lang=ui_lang)
            status, headers, sid_is_valid, body = app.run(request)
        response = Response(response=body, status=status, headers=headers)
        if not sid_is_valid:
            curr_data = dict(request.session)
            request.session = sessions.new()
            request.session.update(curr_data)
            request.session.modified = True
        if request.session.should_save:
            sessions.save(request.session)
            response.set_cookie(sessions.get_cookie_name(), request.session.sid)
        start_response(status, headers)
        return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
    def __call__(self, environ, start_response):
        ui_lang = self.get_lang(environ)
        translation.activate(ui_lang)
        l10n.activate(ui_lang)
        environ['REQUEST_URI'] = wsgiref.util.request_uri(environ)  # TODO remove?
        app_url_prefix = settings.get_str('global', 'action_path_prefix', '')
        if app_url_prefix and environ['PATH_INFO'].startswith(app_url_prefix):
            environ['PATH_INFO'] = environ['PATH_INFO'][len(app_url_prefix):]

        sessions = plugins.runtime.SESSIONS.instance
        request = Request(environ)
        sid = request.cookies.get(sessions.get_cookie_name())
        if sid is None:
            request.session = sessions.new()
        else:
            request.session = sessions.get(sid)

        sid_is_valid = True
        if environ['PATH_INFO'] in ('/', ''):
            url = environ['REQUEST_URI'].split('?')[0]
            if not url.endswith('/'):
                url += '/'
            status = '303 See Other'
            headers = [('Location', '%sfirst_form' % url)]
            body = ''
        # old-style (CGI version) URLs are redirected to new ones
        elif '/run.cgi/' in environ['REQUEST_URI']:
            status = '301 Moved Permanently'
            headers = [('Location', environ['REQUEST_URI'].replace('/run.cgi/', '/'))]
            body = ''
        else:
            controller_class = self.load_controller_class(environ['PATH_INFO'])
            app = controller_class(request=request, ui_lang=ui_lang)
            status, headers, sid_is_valid, body = app.run()
        response = Response(response=body, status=status, headers=headers)
        if not sid_is_valid:
            curr_data = dict(request.session)
            request.session = sessions.new()
            request.session.update(curr_data)
            request.session.modified = True
        if request.session.should_save:
            sessions.save(request.session)
            response.set_cookie(sessions.get_cookie_name(), request.session.sid)
        return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
def create(app, request):
    """Create a new snippet: extract from fields (XXX linenos), render
    ``layouts/show.html`` and save it to data_dir."""

    rv = app.httpbl.query(request.environ.get("HTTP_X_REAL_IP", request.remote_addr))
    if any(filter(lambda typ: typ in (rv['type'] or []), [HARVESTER, COMMENT_SPAMMER])):
        abort(400)

    retry_count = 3
    short_id_length = 32 if request.form.get('private') else 3

    while True:
        pasteid = hashgen(short_id_length)

        if isfile(join(app.data_dir, pasteid)):
            retry_count += 1
            if retry_count > 3:
                short_id_length += 1
                retry_count = 1
        else:
            break

    text = request.form.get('code', request.files.get('file', '')).rstrip()
    lang = request.form.get('lang', 'text')
    linenos = request.form.get('linenos', False)

    if any(filter(lambda k: request.form.get(k) == 'on', ['human', 'tos'])):
        return Response('Moved Temporarily', 301, headers={'Location': '/dev/null'})

    with io.open(join(app.data_dir, pasteid), 'w') as fp:

        fp.write(app.render_template('show.html',
            lang=(None if lang == 'guess' else lang),
            hash=pasteid,
            linenos=(True if linenos == 'on' else False),
            paste=text,
            url=app.host+pasteid
        ))

    response = Response('Moved Temporarily', 301, headers={'Location': request.url_root+pasteid})
    response.set_cookie(pasteid, app.sign(pasteid), max_age=30*24*60*60)  # max. 30 days
    return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
 def my_start_response(status, headers, exc_info=None):
     cookie = ""
     for i, header in enumerate(headers):
         if header[0] == WebService.AUTHENTICATED_COOKIE_HEADER:
             cookie = header[1]
             del headers[i]
             break
     response = Response(status=status, headers=headers)
     remote_addr = environ.get("REMOTE_ADDR")
     if cookie == "delete":
         response.delete_cookie(AWSAuthMiddleware.COOKIE)
     elif cookie == "refresh":
         response.set_cookie(AWSAuthMiddleware.COOKIE, self._get_cookie(admin_id, remote_addr), httponly=True)
     elif cookie.startswith("create:"):
         response.set_cookie(
             AWSAuthMiddleware.COOKIE,
             self._get_cookie(int(cookie.replace("create:", "")), remote_addr),
             httponly=True,
         )
     return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
def application(environ, start_response):
    request = Request(environ)
    path = request.path[1:].split("/")

    name = "root"
    count = 2
    if len(path) > 1:
        count = int(path[1])
    if len(path) > 0:
        name = path[0] or "root"

    html = """
        <html>
            <head><title>Cookie Test</title></head>
            <body>Dropped cookies under name <em>%s</em></body>
        </html>
    """
    response = Response(html % name, mimetype="text/html")
    for n in range(count):
        response.set_cookie("%s%d" % (name, n), "stuff")
    return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
    def __call__(self, environ, start_response):
        request = Request(environ)
        response = Response('')
        self._get_session(request)
        if self._has_session_var(CAS_USERNAME) and not self._is_session_expired(request):
            self._set_values(environ)
            if self._is_logout(environ):
              self._do_session_logout()
              response = self._get_logout_redirect_url()
              return response(environ, start_response)
            return self._application(environ, start_response)
        else:
            params = request.args
            logging.debug('Session not authenticated' + str(self._session))
            if params.has_key('ticket'):
                # Have ticket, validate with CAS server
                ticket = params['ticket']

                service_url = self._effective_url or request.url

                service_url = re.sub(r".ticket=" + ticket, "", service_url)
                logging.debug('Service URL' + service_url)
                logging.debug(str(request))

                username = self._validate(service_url, ticket)

                if username is not None:
                    # Validation succeeded, redirect back to app
                    logging.debug('Validated ' + username)
                    self._set_session_var(CAS_ORIGIN, service_url)
                    self._set_session_var(CAS_TOKEN, ticket)
                    self._save_session()
                    response.status = '302 Moved Temporarily'
                    response.headers['Location'] = service_url
                    return response(environ, start_response)
                else:
                    # Validation failed (for whatever reason)
                    response = self._casfailed(environ, service_url, start_response)
                    return response(environ, start_response)
            else:
                #Check for single sign out
                if (self._is_single_sign_out(environ)):
                  logging.debug('Single sign out request received')
                  response.status = '200 OK'
                  return response(environ, start_response)
                if self._ignore_redirect is not None:
                  if self._ignore_redirect.match(request.url):
                    if self._ignored_callback is not None:
                      return self._ignored_callback(environ, start_response)
                is_gateway = ''
                if self._gateway_redirect is not None:
                  logging.debug('Gateway matching:' + request.url)
                  if self._gateway_redirect.match(request.url):
                    #See if we've been here before
                    gw = self._get_session_var(CAS_GATEWAY)
                    if gw != None:
                      logging.debug('Not logged in carrying on to:' + request.url)
                      self._remove_session_var(CAS_GATEWAY)
                      self._save_session()
                      #A bit paranoid but check it's the same URL
                      if gw == request.url:
                        return self._application(environ, start_response)
                    
                    logging.debug('Checking if logged in to CAS:' + request.url)
                    is_gateway = '&gateway=true'
                    self._set_session_var(CAS_GATEWAY, request.url)
                    self._save_session()
                logging.debug('Does not have ticket redirecting')
                service_url = self._effective_url or request.url
                response.status = '302 Moved Temporarily'
                response.headers['Location'] = '%s?service=%s%s' % (self._login_url, quote(service_url),is_gateway)
                response.set_cookie(CAS_COOKIE_NAME, value = self._session.sid, max_age = None, expires = None)
                return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_cookie [as 别名]
# For most mime types mimetype and content_type work the same, but
# the charset. If the mimetype passed and starting with text/, the
# charset is set. In contrast the content_type parameter is always
#  added as header unmodified.
response = Response('Hello World', status=200)

# inspect #########################################################
# headers
response.headers['Content-Encoding'] = 'gzip'

# request body
response.get_data()
response.set_data()

# cookies
response.set_cookie('username', 'John')

# get (app_iter, status, headers)
response.get_wsig_response()


###############################################################################
#                            Request
#     The request object is immutable. Modifications are not supported by
# default, you may however replace the immutable attributes with mutable
# attributes if you need to modify it.
#     The request object may be shared in the same thread, but is not thread
# safe itself.
#     It's not possible to pickle the request object.
###############################################################################
environ = {'REQUEST_METHOD': 'GET',