Python SecureCookie.unserialize方法代码示例

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
def test_basic_support():
    c = SecureCookie(secret_key=b'foo')
    assert c.new
    assert not c.modified
    assert not c.should_save
    c['x'] = 42
    assert c.modified
    assert c.should_save
    s = c.serialize()

    c2 = SecureCookie.unserialize(s, b'foo')
    assert c is not c2
    assert not c2.new
    assert not c2.modified
    assert not c2.should_save
    assert c2 == c

    c3 = SecureCookie.unserialize(s, b'wrong foo')
    assert not c3.modified
    assert not c3.new
    assert c3 == {}

    c4 = SecureCookie({'x': 42}, 'foo')
    c4_serialized = c4.serialize()
    assert SecureCookie.unserialize(c4_serialized, 'foo') == c4

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
def login():
    #import logging
    #logging.info('sgvsevr')
    form = LoginForm()
    if request.method == 'POST':
        if form.validate_on_submit():
            user = User.query.filter_by(account=form.name.data).first()
            if user is not None and user.verify_password(form.password.data):
                resp = make_response(redirect(url_for('account.index', account=user.account)))
                cookie_value = SecureCookie({'user': form.name.data, 'rn': user.username,
                                            'uid': user.id, 'permission': user.permission,
                                             'timestamp': time.time()}, SECRET_KEY).serialize()
                # x = SecureCookie.unserialize(value, SECRET_KEY)
                resp.set_cookie('info', cookie_value, expires=time.time() + COOKIE_EXPIRES)
                # expires=COOKIE_EXPIRES
                return resp
            flash('1-Invalid username or password.')
            return render_template('login.html', form=form)
        flash('用户名或密码错误')
        return render_template('login.html', form=form)
    else:
        cookie_info = request.cookies.get('info')
        if cookie_info:
            info = SecureCookie.unserialize(cookie_info, SECRET_KEY)
            user, timesite = info.get('user'), info.get('timestamp')
            _user = User.query.filter_by(account=user).first()
            if _user:
                if (time.time() - timesite) < COOKIE_EXPIRES:
                    return redirect(url_for('account.index', account=user))
                return render_template('login.html', form=form)
        return render_template('login.html', form=form)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
    def oauth_callback(self, request):
        if request.args.get("denied") is not None:
            return False

        try:
            oauth_data = SecureCookie.unserialize(request.cookies["twitter_oauth"], self.consumer_secret)
        except KeyError:
            return False

        oauth_token = oauth2.Token(oauth_data["oauth_token"], oauth_data["oauth_token_secret"])
        oauth_token.set_verifier(request.args.get("oauth_verifier"))

        oauth_consumer  = oauth2.Consumer(key=self.consumer_key, secret=self.consumer_secret)
        oauth_client    = oauth2.Client(oauth_consumer, oauth_token)

        resp, content   = oauth_client.request(ACCESS_TOKEN_URL, "POST")
        if resp["status"] != "200":
            return False
        oauth_data = dict(parse_qsl(content))

        user_data = twitter.Api(consumer_key=self.consumer_key,
                                consumer_secret=self.consumer_secret,
                                access_token_key=oauth_data["oauth_token"],
                                access_token_secret=oauth_data["oauth_token_secret"]).VerifyCredentials().AsDict()
        return (user_data["id"], dict(user_data, **oauth_data))

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
    def get(self):
        args = self.request.args
        response_type = args.get("response_type")
        client_id = args.get("client_id")
        redirect_uri = args.get("redirect_uri")
        scope = args.get("scope")
        state = args.get("state","")

        if response_type is None or client_id is None or redirect_uri is None:
            return self.error("The request invalid")

        data = self.request.cookies.get("l")
        if data is not None:
            login_data = SecureCookie.unserialize(data, self.settings.secret_key)
        else:
            self.settings.log.debug("cookie for user login data not found")
            login_data = {}
        if not login_data.has_key("username"):
            # not logged in, show login form
            self.settings.log.debug("redirecting to login form")
            return self.login_form()
        else: 
            # logged in, retrieve an auth code and do the redirect
            username = login_data['username']
            am = self.settings.authmanager
            try:
                token, auth_code = am.new_token(username, client_id)
            except usermanager.errors.ClientNotFound, e:
                return self.error("the client_id is incorrect")
            q = {
                'code' : auth_code,
                'state' : state,
            }
            url = redirect_uri+"?"+urllib.urlencode(q)
            return werkzeug.redirect(url)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
    def is_authorized(self, request, op_request):
        data = request.cookies.get('session_data')
        if data:
            session = SecureCookie.unserialize(data, SECRET_KEY)

            if session.get("logged_in", False) == True:
                return True

        return False

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
 def get(self, **kw):
     """post a new vote to this poll"""
     _id = self.item._id
     data = self.request.cookies.get("qlpoll")
     if data is not None:
         poll_data = SecureCookie.unserialize(data, self.settings.secret_key)
     else:
         poll_data = {'_id' : None}
     voted = poll_data['_id']==_id
     return {'voted' : voted}

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
def _get_flash_msg(request):
  if 'ls_message' in request.cookies:
    update_message = SecureCookie.unserialize(
      request.cookies['ls_message'],
      settings.SECRET_KEY,
    )
    delete_cookie('ls_message')
    return update_message['m']
  else:
    return None

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
    def test_basic_support(self):
        c = SecureCookie(secret_key=b'foo')
        assert c.new
        assert not c.modified
        assert not c.should_save
        c['x'] = 42
        assert c.modified
        assert c.should_save
        s = c.serialize()

        c2 = SecureCookie.unserialize(s, b'foo')
        assert c is not c2
        assert not c2.new
        assert not c2.modified
        assert not c2.should_save
        self.assert_equal(c2, c)

        c3 = SecureCookie.unserialize(s, b'wrong foo')
        assert not c3.modified
        assert not c3.new
        self.assert_equal(c3, {})

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
    def test_basic_support(self):
        c = SecureCookie(secret_key='foo')
        assert c.new
        assert not c.modified
        assert not c.should_save
        c['x'] = 42
        assert c.modified
        assert c.should_save
        s = c.serialize()

        c2 = SecureCookie.unserialize(s, 'foo')
        assert c is not c2
        assert not c2.new
        assert not c2.modified
        assert not c2.should_save
        assert c2 == c

        c3 = SecureCookie.unserialize(s, 'wrong foo')
        assert not c3.modified
        assert not c3.new
        assert c3 == {}

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
    def test_basic_support(self):
        c = SecureCookie(secret_key="foo")
        assert c.new
        print c.modified, c.should_save
        assert not c.modified
        assert not c.should_save
        c["x"] = 42
        assert c.modified
        assert c.should_save
        s = c.serialize()

        c2 = SecureCookie.unserialize(s, "foo")
        assert c is not c2
        assert not c2.new
        assert not c2.modified
        assert not c2.should_save
        assert c2 == c

        c3 = SecureCookie.unserialize(s, "wrong foo")
        assert not c3.modified
        assert not c3.new
        assert c3 == {}

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
def get_gaema_user(service):
  try:
    gaema_user_key = GAEMA_USER_KEY_FORMAT % service
    if hasattr(settings, "GAEMA_STORAGE") and \
          settings.GAEMA_STORAGE == "cookie":
      user_data = local.request.cookies.get(gaema_user_key, None)
      if user_data:
        return SecureCookie.unserialize(user_data,
                                        secret_key=settings.SECRET_KEY)
    else:
      return local.request.session.get(gaema_user_key, None)
  except Exception, e:
    raise InternalServerError('Getting gaema_user failed, reason: %s' % e)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
 def get(self):
     """return the user related data"""
     userdata = self.request.cookies.get("u", None)        
     userdata = SecureCookie.unserialize(userdata, self.settings.secret_key)
     cm = self.settings.contentmanager
     d = {
         'userdata' : userdata,
         'poco' : userdata['poco'],
         'token' : userdata['token'],
         'root' : cm.root.json,
         'types' : cm.content_types.json,
         'scraper' : 'http://pagescraper.mrtopf.clprojects.net'
     }
     return d

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
 def decorator(*args, **kwargs):
     cookie_info = request.cookies.get('info')
     if cookie_info:
         info = SecureCookie.unserialize(cookie_info, SECRET_KEY)
         user, uid, timesite = info.get('user'), \
             info.get('uid'), info.get('timestamp')
         permission, rn = info.get('permission'), info.get('rn')
         request.uid, request.user, request.permission = uid,\
             user, permission
         request.rn = rn
         if (time.time() - timesite) >= COOKIE_EXPIRES:
             flash('deco-1会话已过期，请重新登录')
             return redirect(url_for('account.login'))
     else:
         flash('deco-2会话已过期，请重新登录')
         return redirect(url_for('account.login'))
     return func(*args, **kwargs)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
def index(account):
    form = LoginForm()
    # return 'sdbvgsdf'
    info = request.cookies.get('info')
    if info:
        cookie_value = SecureCookie.unserialize(info, SECRET_KEY)
        if account == cookie_value.get('user'):
            today = datetime.datetime.now()
            year = today.isocalendar()[0]
            week_total = today.isocalendar()[1]
            uid = cookie_value.get('uid')
            permission, rn = cookie_value.get('permission'), cookie_value.get('rn')
            return render_template('index.html', year=year, week_total=week_total,
                                   uid=uid, account=account, permission=permission,
                                   rn=rn)
        else:
            render_template('login.html', form=form)
    return render_template('login.html', form=form)

# 需要导入模块: from werkzeug.contrib.securecookie import SecureCookie [as 别名]
# 或者: from werkzeug.contrib.securecookie.SecureCookie import unserialize [as 别名]
    def pre_process(self, environ):
        request = Request(environ)
        for prefix in self.excluded_paths:
            if request.path.startswith(prefix):
                return

        cookie = request.cookies.get(self.name)
        if not cookie:
            return

        session = SecureCookie.unserialize(cookie, self.secret)

        if not self.fetch_user:
            user = User()
            user._session_token = session['session_token']
            user.id = session['uid']
            User.set_current(user)
        else:
            user = User.become(session['session_token'])
            User.set_current(user)