Python current_user.get_id方法代码示例

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def settings():
    """Render the settings page."""
    c = mongo.db[app.config['USERS_COLLECTION']]
    user = c.find_one({'username': current_user.get_id()})
    if not user:
        return render_template()
    user['id'] = str(user['_id'])
    user.pop('_id', None)
    if current_user.is_admin():
        g = mongo.db[app.config['GLOBAL_COLLECTION']]
        data = g.find_one(dict(), {'_id': 0})
        user['admin'] = data
    user['has_session'] = True
    if not os.path.exists(SESSION_FILE):
        user['has_session'] = False
    return render_template('settings.html', user=user) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def test_editor_get(self):
        user_id = "testuser"
        with self.client:
            # access to editor should be forbidden before login
            response = self.client.get("/blog/editor/")
            self.assertEqual(response.status_code, 401)

            response = self.client.get("/blog/editor/%s/" % self.pids[0])
            self.assertEqual(response.status_code, 401)

            self.login(user_id)
            self.assertEquals(current_user.get_id(), user_id)
            response = self.client.get("/blog/editor/")
            assert response.status_code == 200

            for i in range(1, 21):
                # logged in user can edit their post, and will be redirected
                # if they try to edit other's post
                response = self.client.get("/blog/editor/%s/" % self.pids[i-1])
                expected_status_code = 200 if i <= 10 else 302
                self.assertEqual(response.status_code, expected_status_code,
                                 "Error for item %s %d" %
                                 (self.pids[i - 1], response.status_code))
            # logout and the access should be gone again
            self.logout()
            response = self.client.get("/blog/editor/")
            self.assertEqual(response.status_code, 401)

            response = self.client.get("/blog/editor/%s/" % self.pids[0])
            self.assertEqual(response.status_code, 401) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def test_editor_post(self):
        user_id = "testuser"
        with self.client:
            # access to editor should be forbidden before login
            response = self.client.get("/blog/page/21/",
                                       follow_redirects=True)
            assert "The page you are trying to access is not valid!" in \
                   str(response.data)

            response = self.client.post("/blog/editor/")
            self.assertEqual(response.status_code, 401)

            response = self.client.post("/blog/editor/%s/" % self.pids[0])
            self.assertEqual(response.status_code, 401)

            self.login(user_id)
            self.assertEquals(current_user.get_id(), user_id)

            response = self.client.post("/blog/editor/",
                                        data=dict(text="Test Text",
                                                  tags="tag1, tag2"))
            # should give back the editor page
            self.assertEqual(response.status_code, 200)

            response = self.client.post("/blog/editor/",
                                        data=dict(title="Test Title",
                                                  text="Test Text",
                                                  tags="tag1, tag2"))
            self.assertEqual(response.status_code, 302)

            response = self.client.get("/blog/page/%s/" % self.pids[19])
            self.assertEqual(response.status_code, 200) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def test_delete(self):
        user_id = "testuser"
        with self.client:

            # Anonymous user cannot delete
            response = self.client.post("/blog/delete/%s/" % self.pids[0])
            self.assertEqual(response.status_code, 401)

            # a user cannot delete another person's post
            self.login(user_id)
            self.assertEquals(current_user.get_id(), user_id)
            response = self.client.post("/blog/delete/%s/" % self.pids[12],
                                        follow_redirects=True)
            assert "You do not have the rights to delete this post" in \
                   str(response.data)

            # a user can delete his posts
            response = self.client.post("/blog/delete/%s/" % self.pids[0],
                                        follow_redirects=True)
            assert "Your post was successfully deleted" in str(response.data) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def test_permissions_delete(self):
        self.app.config["BLOGGING_PERMISSIONS"] = True
        # Assuming "BLOGGING_PERMISSIONNAME" read failure
        # self.app.config["BLOGGING_PERMISSIONNAME"] = None
        user_id = "testuser"
        self._set_identity_loader(self.app.config.get(
            "BLOGGING_PERMISSIONNAME", "blogger"))

        with self.client:
            # Anonymous user cannot delete
            response = self.client.post("/blog/delete/%s/" % self.pids[0])
            self.assertEqual(response.status_code, 401)

            self.login(user_id)
            # non blogger cannot delete posts
            response = self.client.post("/blog/delete/%s/" % self.pids[0])
            self.assertEqual(response.status_code, 302)  # will be redirected
            self.logout()

            self.login(user_id, blogger=True)
            response = self.client.post("/blog/delete/%s/" % self.pids[0],
                                        follow_redirects=True)
            assert "Your post was successfully deleted" in str(response.data)

            # a user cannot delete another person's post
            self.assertEquals(current_user.get_id(), user_id)
            response = self.client.post("/blog/delete/%s/" % self.pids[10],
                                        follow_redirects=True)
            assert "You do not have the rights to delete this post" in \
                   str(response.data)

            test_permission = Permission(RoleNeed("testblogger"))
            blogger_permission = Permission(RoleNeed("blogger"))
            self.assertFalse(test_permission.issubset(
                self.engine.blogger_permission))
            self.assertTrue(blogger_permission.issubset(
                self.engine.blogger_permission)) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def user_id(self):
        """
        Return the ID of the current request's user
        """
        # This needs flask-login to be installed
        if not has_flask_login:
            return

        # and the actual login manager installed
        if not hasattr(current_app, "login_manager"):
            return

        # fail if no current_user was attached to the request context
        try:
            is_authenticated = current_user.is_authenticated
        except AttributeError:
            return

        # because is_authenticated could be a callable, call it
        if callable(is_authenticated):
            is_authenticated = is_authenticated()

        # and fail if the user isn't authenticated
        if not is_authenticated:
            return

        # finally return the user id
        try:
            return current_user.get_id()
        except UserLoadingError:
            # but don't fail if for some reason getting the user id
            # created an exception to not accidently make exception
            # handling worse. If sqlalchemy is used that catches
            # all SQLAlchemyError exceptions.
            pass 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def get_astroprint_info():
	if current_user and current_user.is_authenticated and current_user.privateKey:
		return jsonify(user=current_user.get_id())
	else:
		return jsonify(user=None) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def validate_session_cookie(auth_header_unusued=None):
    """
    Attempts to load a user from a session cookie.
    """
    if current_user.is_anonymous:
        return ValidateResult(AuthKind.cookie, missing=True)

    try:
        # Attempt to parse the user uuid to make sure the cookie has the right value type
        UUID(current_user.get_id())
    except ValueError:
        logger.debug("Got non-UUID for session cookie user: %s", current_user.get_id())
        return ValidateResult(AuthKind.cookie, error_message="Invalid session cookie format")

    logger.debug("Loading user from cookie: %s", current_user.get_id())
    db_user = current_user.db_user()
    if db_user is None:
        return ValidateResult(AuthKind.cookie, error_message="Could not find matching user")

    # Don't allow disabled users to login.
    if not db_user.enabled:
        logger.debug("User %s in session cookie is disabled", db_user.username)
        return ValidateResult(AuthKind.cookie, error_message="User account is disabled")

    # Don't allow organizations to "login".
    if db_user.organization:
        logger.debug("User %s in session cookie is in-fact organization", db_user.username)
        return ValidateResult(AuthKind.cookie, error_message="Cannot login to organization")

    return ValidateResult(AuthKind.cookie, user=db_user) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def change_password():
    password1 = request.form.get('password1')
    password2 = request.form.get('password2')
    error = request.args.get('error')

    if error:
        return render_template("change_password.html", error=error)

    if current_user.is_authenticated and password1!=None:
        if password1==password2:
            if check_password_strength(password1):
                user_id = current_user.get_id()
                create_user_db(user_id , password1, update=True)
                return redirect(url_for('dashboard.index'))
            else:
                error = 'Incorrect password'
                return render_template("change_password.html", error=error)
        else:
            error = "Passwords don't match"
            return render_template("change_password.html", error=error)
    else:
        error = 'Please choose a new password'
        return render_template("change_password.html", error=error) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def manual():
    user_id = current_user.get_id()
    l_cookiejar = crawlers.api_get_cookies_list_select(user_id)
    return render_template("crawler_manual.html", crawler_enabled=True, l_cookiejar=l_cookiejar) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def send_to_spider():
    user_id = current_user.get_id()

    # POST val
    url = request.form.get('url_to_crawl')
    auto_crawler = request.form.get('crawler_type')
    crawler_delta = request.form.get('crawler_epoch')
    screenshot = request.form.get('screenshot')
    har = request.form.get('har')
    depth_limit = request.form.get('depth_limit')
    max_pages = request.form.get('max_pages')
    cookiejar_uuid = request.form.get('cookiejar')

    if cookiejar_uuid:
        if cookiejar_uuid == 'None':
            cookiejar_uuid = None
        else:
            cookiejar_uuid = cookiejar_uuid.rsplit(':')
            cookiejar_uuid = cookiejar_uuid[-1].replace(' ', '')

    res = crawlers.api_create_crawler_task(user_id, url, screenshot=screenshot, har=har, depth_limit=depth_limit, max_pages=max_pages,
                                                    auto_crawler=auto_crawler, crawler_delta=crawler_delta, cookiejar_uuid=cookiejar_uuid)
    if res:
        return create_json_response(res[0], res[1])
    return redirect(url_for('crawler_splash.manual'))

# add route : /crawlers/show_domain 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def crawler_cookiejar_add_post():
    user_id = current_user.get_id()

    description = request.form.get('description')
    level = request.form.get('level')
    if level:
        level = 1
    else:
        level = 0

    if 'file' in request.files:
        file = request.files['file']
        json_cookies = file.read().decode()
    else:
        json_cookies = None

    # Get cookies to add
    l_manual_cookie = []
    l_invalid_cookie = []
    for obj_tuple in list(request.form):
        l_input = request.form.getlist(obj_tuple)
        if len(l_input) == 2:
            if l_input[0]: # cookie_name
                cookie_dict = {'name': l_input[0], 'value': l_input[1]}
                l_manual_cookie.append(cookie_dict)
            elif l_input[1]: # cookie_value
                    l_invalid_cookie.append({'name': '', 'value': l_input[1]})
    if l_invalid_cookie:
        return create_json_response({'error': 'invalid cookie', 'invalid fileds': l_invalid_cookie}, 400)

    cookiejar_uuid = crawlers.create_cookiejar(user_id, level=level, description=description)
    if json_cookies:
        res = crawlers.api_import_cookies_from_json(json_cookies, cookiejar_uuid)
        if res:
            return create_json_response(res[0], res[1])
    if l_manual_cookie:
        crawlers.add_cookies_to_cookiejar(cookiejar_uuid, l_manual_cookie)

    return redirect(url_for('crawler_splash.crawler_cookiejar_show', cookiejar_uuid=cookiejar_uuid)) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def crawler_cookiejar_show():
    user_id = current_user.get_id()
    cookiejar_uuid = request.args.get('cookiejar_uuid')

    res = crawlers.api_get_cookiejar_cookies_with_uuid(cookiejar_uuid, user_id)
    if res[1] !=200:
        return create_json_response(res[0], res[1])

    cookiejar_metadata = crawlers.get_cookiejar_metadata(cookiejar_uuid, level=False)

    l_cookies = []
    l_cookie_uuid = []
    for cookie in res[0]:
        l_cookies.append(json.dumps(cookie[0], indent=4, sort_keys=True))
        l_cookie_uuid.append(cookie[1])
    return render_template("show_cookiejar.html", cookiejar_uuid=cookiejar_uuid, cookiejar_metadata=cookiejar_metadata,
                                        l_cookies=l_cookies, l_cookie_uuid=l_cookie_uuid) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def crawler_cookiejar_cookie_delete():
    user_id = current_user.get_id()
    cookiejar_uuid = request.args.get('cookiejar_uuid')
    cookie_uuid = request.args.get('cookie_uuid')

    res = crawlers.api_delete_cookie_from_cookiejar(user_id, cookiejar_uuid, cookie_uuid)
    if res[1] !=200:
        return create_json_response(res[0], res[1])
    return redirect(url_for('crawler_splash.crawler_cookiejar_show', cookiejar_uuid=cookiejar_uuid)) 

# 需要导入模块: from flask_login import current_user [as 别名]
# 或者: from flask_login.current_user import get_id [as 别名]
def crawler_cookiejar_delete():
    user_id = current_user.get_id()
    cookiejar_uuid = request.args.get('cookiejar_uuid')

    res = crawlers.api_delete_cookie_jar(user_id, cookiejar_uuid)
    if res[1] !=200:
        return create_json_response(res[0], res[1])
    return redirect(url_for('crawler_splash.crawler_cookiejar_all'))