コード例 #1
0
ファイル: users.py プロジェクト: AtlasFontaine/longboxed
 def run(self):
     name = prompt('Role Name')
     description = prompt('Role Description')
     _security_datastore = LocalProxy(lambda: current_app.extensions['security'].datastore)
     _security_datastore.create_role(name=name, description=description)
     db.session.commit()
     return
コード例 #2
0
ファイル: users.py プロジェクト: coinchirp/longboxed
def delete():
    email = g.current_user.email
    _security_datastore = LocalProxy(lambda:
            current_app.extensions['security'].datastore)
    _security_datastore.delete_user(g.current_user)
    _security_datastore.commit()
    return jsonify(dict(user=email, message='Successfully deleted user!'))
コード例 #3
0
ファイル: users.py プロジェクト: AtlasFontaine/longboxed
 def run(self):
     default_roles = [('user', 'No Permissions'), ('admin', 'Comic specific permissions'), ('super', 'All permissions')]
     _security_datastore = LocalProxy(lambda: current_app.extensions['security'].datastore)
     for role in default_roles:
         _security_datastore.find_or_create_role(name=role[0], description=role[1])
         db.session.commit()
     print 'Sucessfully added roles'
コード例 #4
0
ファイル: app.py プロジェクト: tiborsimko/invenio-circulation
def user():
    """Create circulation admin user."""
    from werkzeug.local import LocalProxy
    from flask_security.utils import encrypt_password

    from invenio_db import db
    from invenio_oauth2server.models import Token

    _datastore = LocalProxy(lambda: app.extensions['security'].datastore)
    kwargs = dict(
        email='*****@*****.**',
        password='******',
        active=True
    )
    kwargs['password'] = encrypt_password(kwargs['password'])
    user = _datastore.create_user(**kwargs)

    Token.create_personal(
        'test-personal-{0}'.format(user.id),
        user.id,
        scopes=['webhooks:event'],
        is_internal=True,
    ).access_token

    db.session.commit()
コード例 #5
0
def access_request(pid, record, template, **kwargs):
    """Create an access request."""
    recid = int(pid.pid_value)
    datastore = LocalProxy(
        lambda: current_app.extensions['security'].datastore)

    # Record must be in restricted access mode.
    if record.get('access_right') != 'restricted' or \
       not record.get('access_conditions'):
        abort(404)

    # Record must have an owner and owner must still exists.
    owners = record.get('owners', [])
    record_owners = [datastore.find_user(id=owner_id) for owner_id in owners]
    if not record_owners:
        abort(404)

    sender = None
    initialdata = dict()

    # Prepare initial form data
    if current_user.is_authenticated:
        sender = current_user
        initialdata['email'] = current_user.email
        if current_user.profile:
            initialdata['full_name'] = current_user.profile.full_name

    # Normal form validation
    form = AccessRequestForm(formdata=request.form, **initialdata)

    if form.validate_on_submit():
        accreq = AccessRequest.create(
            recid=recid,
            receiver=record_owners[0],
            sender_full_name=form.data['full_name'],
            sender_email=form.data['email'],
            justification=form.data['justification'],
            sender=sender
        )
        db.session.commit()

        if accreq.status == RequestStatus.EMAIL_VALIDATION:
            flash(_(
                "Email confirmation needed: We have sent you an email to "
                "verify your address. Please check the email and follow the "
                "instructions to complete the access request."),
                category='info')
        else:
            flash(_("Access request submitted."), category='info')
        return redirect(url_for('invenio_records_ui.recid', pid_value=recid))

    return render_template(
        template,
        pid=pid,
        record=record,
        form=form,
        owners=record_owners,
    )
コード例 #6
0
ファイル: dashboard.py プロジェクト: coinchirp/longboxed
def delete_account():
    delete_user_account_form = DeleteUserAccountForm()
    if delete_user_account_form.validate_on_submit():
        user_temp = User.query.get(current_user.id)
        logout_user()
        _security_datastore = LocalProxy(lambda: current_app.extensions['security'].datastore)
        _security_datastore.delete_user(user_temp)
        _security_datastore.commit()
    return redirect(url_for('dashboard.index'))
コード例 #7
0
def test_local_proxies_with_callables():
    """Use a callable with a local proxy"""
    foo = 42
    ls = LocalProxy(lambda: foo)
    assert ls == 42
    foo = [23]
    ls.append(42)
    assert ls == [23, 42]
    assert foo == [23, 42]
コード例 #8
0
ファイル: views_my_account.py プロジェクト: Oddly/MALMan
def account_edit_own_password():
    form = forms.MembersEditPassword()
    _security = LocalProxy(lambda: current_app.extensions['security'])
    _datastore = LocalProxy(lambda: _security.datastore)
    if form.validate_on_submit():
        update_password(current_user, request.form['password'])
        _datastore.commit()
        flash("your password was updated", "confirmation")
        return redirect(request.url)
    return render_template('my_account/edit_password.html', form=form)
コード例 #9
0
ファイル: pcb_drill_web.py プロジェクト: dustinbcox/pcb_drill
def generate_response(name, template, **kwargs):
    """ Handle the general response with template rendering, etc"""
    nav_menu_bar = LocalProxy(get_nav_menu_items)
    nav_menu_bar.set_active(name)
    body = render_template(template, current_date=time.ctime(), **kwargs)
    response = make_response(body)
    # ;-)
    response.headers['X-Powered-By'] = 'Not-PHP/1.0'
    if 'pcb_drill_session' not in session:
        session['pcb_drill_session'] = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M_%S.%f')
    return response
コード例 #10
0
ファイル: users.py プロジェクト: AtlasFontaine/longboxed
 def run(self):
     email = prompt('Email')
     # user = users.first(email=email)
     user = User.query.filter_by(email=email).first()
     if user:
         _security_datastore = LocalProxy(lambda: current_app.extensions['security'].datastore)
         admin_role = _security_datastore.find_role('admin')
         _security_datastore.add_role_to_user(user, admin_role)
         db.session.commit()
         print '\nUser given admin role sucessfully'
         return
     print '\nNo user found'
コード例 #11
0
def test_local_proxy():
    """Tests some proxy operations"""
    foo = []
    ls = LocalProxy(lambda: foo)
    ls.append(42)
    ls.append(23)
    ls[1:] = [1, 2, 3]
    assert foo == [42, 1, 2, 3]
    assert repr(foo) == repr(ls)
    assert foo[0] == 42
    foo += [1]
    assert list(foo) == [42, 1, 2, 3, 1]
コード例 #12
0
def create_user_with_role(username, rolename):
    _datastore = LocalProxy(
        lambda: current_app.extensions['security'].datastore)

    user, role = _datastore._prepare_role_modify_args(username, rolename)

    if not user:
        user = create_test_user(email=username, password='******')
    if not role:
        role = _datastore.create_role(name=rolename)

    _datastore.add_role_to_user(user, role)

    return user
コード例 #13
0
ファイル: signals.py プロジェクト: AtlasFontaine/longboxed
def user_registered_signal_handler(app, user, confirm_token):
    """Executed imediately after user registers a new account.
    Adds a default 'user' role to the new user

    :param app: Flask application object
    :param user: Newly registered Flask-Login User object
    :param confirm_token: Users confirm token
    """
    _security_datastore = LocalProxy(lambda: app.extensions["security"].datastore)
    default_role = _security_datastore.find_role("user")
    _security_datastore.add_role_to_user(user, default_role)
    db.session.commit()
    Bundle.refresh_user_bundle(user, current_wednesday())
    Bundle.refresh_user_bundle(user, next_wednesday())
    Bundle.refresh_user_bundle(user, two_wednesdays())
コード例 #14
0
def access_token(app, db):
    _datastore = LocalProxy(lambda: app.extensions['security'].datastore)
    kwargs = dict(email='*****@*****.**', password='******',
                  active=True)
    kwargs['password'] = encrypt_password(kwargs['password'])
    user = _datastore.create_user(**kwargs)

    db.session.commit()
    token = Token.create_personal(
        'test-personal-{0}'.format(user.id),
        user.id,
        scopes=['webhooks:event'],
        is_internal=True,
    ).access_token
    db.session.commit()

    yield token
コード例 #15
0
# -*- coding: utf-8 -*-

import os
from werkzeug.local import LocalProxy
from flask import current_app, request, jsonify, render_template, send_file, session, redirect

from ..core import AppError
from .. import factory
from .. import errors
from .. import settings
from .. import app_user_manager
from ..helpers.flask_helper import _endpoint_url

_logger = LocalProxy(lambda: current_app.logger)


def create_app():
    settings_override = {
        'USER_ENABLE_REGISTRATION': False,
        'SQLALCHEMY_POOL_SIZE': 5,
    }

    app = factory.create_app(__name__, __path__, settings_override, logger_name='backend')
    app.errorhandler(AppError)(on_app_error)
    app.errorhandler(Exception)(unhandle_error)
    app.errorhandler(404)(on_404)
    app.errorhandler(500)(on_500)

    from .manager_login import manager_do_login
    app_user_manager.init_user_manager(app, manager_do_login)
コード例 #16
0
ファイル: views.py プロジェクト: gothm/flask-security
     ResetPasswordError, PasswordlessLoginError
from flask_security.forms import LoginForm, RegisterForm, ForgotPasswordForm, \
     ResetPasswordForm, SendConfirmationForm, PasswordlessLoginForm
from flask_security.passwordless import send_login_instructions, login_by_token
from flask_security.recoverable import reset_by_token, \
     send_reset_password_instructions
from flask_security.signals import user_registered
from flask_security.utils import get_url, get_post_login_redirect, do_flash, \
     get_message, config_value, login_user, logout_user, \
     anonymous_user_required, url_for_security as url_for


# Convenient references
_security = LocalProxy(lambda: app.extensions['security'])

_datastore = LocalProxy(lambda: _security.datastore)

_logger = LocalProxy(lambda: app.logger)


def _json_auth_ok(user):
    return jsonify({
        "meta": {
            "code": 200
        },
        "response": {
            "user": {
                "id": str(user.id),
                "authentication_token": user.get_auth_token()
            }
        }
コード例 #17
0
ファイル: utils.py プロジェクト: kaorisakai/weko
#
# This file is part of Invenio.
# Copyright (C) 2017-2018 CERN.
#
# Invenio is free software; you can redistribute it and/or modify it
# under the terms of the MIT License; see LICENSE file for more details.
# from .signals import secret_key_changed
"""Invenio-DB utility functions."""

from flask import current_app
from sqlalchemy.engine import reflection
from werkzeug.local import LocalProxy

from .shared import db

_db = LocalProxy(lambda: current_app.extensions['sqlalchemy'].db)


def rebuild_encrypted_properties(old_key, model, properties):
    """Rebuild a model's EncryptedType properties when the SECRET_KEY is changed.

    :param old_key: old SECRET_KEY.
    :param model: the affected db model.
    :param properties: list of properties to rebuild.
    """
    inspector = reflection.Inspector.from_engine(db.engine)
    primary_key_names = inspector.get_primary_keys(model.__tablename__)

    new_secret_key = current_app.secret_key
    db.session.expunge_all()
    try:
コード例 #18
0
def get_cart_class():
    key = 'cart'
    return LocalProxy(import_shop_object(key))
コード例 #19
0
from flask_babelex import lazy_gettext as _
from invenio_drafts_resources.services.records.schema import RecordSchema
from marshmallow import ValidationError, fields, post_dump, validates
from marshmallow_utils.fields import NestedAttribute
from marshmallow_utils.permissions import FieldPermissionsMixin
from marshmallow_utils.schemas import IdentifierSchema
from werkzeug.local import LocalProxy

from .access import AccessSchema
from .files import FilesSchema
from .metadata import MetadataSchema
from .parent import RDMParentSchema
from .pids import PIDSchema
from .versions import VersionsSchema

record_pids_schemes = LocalProxy(
    lambda: current_app.config["RDM_RECORDS_RECORD_PID_SCHEMES"])


class RDMRecordSchema(RecordSchema, FieldPermissionsMixin):
    """Record schema."""

    field_load_permissions = {
        'files': 'update_draft',
    }

    # ATTENTION: In this schema you should be using the ``NestedAttribute``
    # instead  of Marshmallow's ``fields.Nested``. Using NestedAttribute
    # ensures that the nested schema will receive the system field instead of
    # the record dict (i.e. record.myattr instead of record['myattr']).

    pids = fields.Dict(keys=fields.String(), values=fields.Nested(PIDSchema))
コード例 #20
0
ファイル: utils.py プロジェクト: mb-wali/sonar
#
# Swiss Open Access Repository is free software; you can redistribute it
# and/or modify it under the terms of the MIT License; see LICENSE file for
# more details.
"""Utility methods to help find, authenticate or register a remote user."""

from __future__ import absolute_import, print_function

from urllib.parse import urlparse

import uritools
from flask import current_app, request
from slugify import slugify
from werkzeug.local import LocalProxy

_security = LocalProxy(lambda: current_app.extensions['security'])

_datastore = LocalProxy(lambda: _security.datastore)


def get_account_info(attributes, remote_app):
    """Return account info for remote user.

    :param attributes: (dict) dictionary of data returned by identity provider.
    :param remote_app: (str) Identity provider key.
    :returns: (dict) A dictionary representing user to create or update.
    """
    mappings = current_app.config['SHIBBOLETH_IDENTITY_PROVIDERS'][remote_app][
        'mappings']

    # Map data according to configuration
コード例 #21
0
ファイル: globals.py プロジェクト: moevm/mse_tourist_planner

def _lookup_req_object(name):
    top = _request_ctx_stack.top
    if top is None:
        raise RuntimeError(_request_ctx_err_msg)
    return getattr(top, name)


def _lookup_app_object(name):
    top = _app_ctx_stack.top
    if top is None:
        raise RuntimeError(_app_ctx_err_msg)
    return getattr(top, name)


def _find_app():
    top = _app_ctx_stack.top
    if top is None:
        raise RuntimeError(_app_ctx_err_msg)
    return top.app


# context locals
_request_ctx_stack = LocalStack()
_app_ctx_stack = LocalStack()
current_app = LocalProxy(_find_app)
request = LocalProxy(partial(_lookup_req_object, 'request'))
session = LocalProxy(partial(_lookup_req_object, 'session'))
g = LocalProxy(partial(_lookup_app_object, 'g'))
コード例 #22
0
ファイル: proxies.py プロジェクト: topless/invenio-accounts
# -*- coding: utf-8 -*-
#
# This file is part of Invenio.
# Copyright (C) 2017-2018 CERN.
#
# Invenio is free software; you can redistribute it and/or modify it
# under the terms of the MIT License; see LICENSE file for more details.
"""Helper proxy to the state object."""

from flask import current_app
from werkzeug.local import LocalProxy

current_accounts = LocalProxy(
    lambda: current_app.extensions['invenio-accounts'])
"""Proxy to the current Invenio-Accounts extension."""

current_security = LocalProxy(lambda: current_app.extensions['security'])
"""Proxy to the Flask-Security extension."""

current_datastore = LocalProxy(
    lambda: current_app.extensions['security'].datastore)
"""Proxy to the current Flask-Security user datastore."""
コード例 #23
0
def authentication_header_handler(apikey, required_scopes=None):
    try:
        identity = from_auth_header(apikey)
        validate(identity)
    except Exception:
        login_failure_count.inc()
        logger.debug("Failed to validate identity header value", exc_info=True)
        return None

    return {"uid": identity}


def bearer_token_handler(token):
    try:
        identity = from_bearer_token(token)
        validate(identity)
    except Exception:
        login_failure_count.inc()
        logger.debug("Failed to validate bearer token value", exc_info=True)
        return None

    return {"uid": identity}


def _get_identity():
    return connexion.context["user"]


current_identity = LocalProxy(_get_identity)
コード例 #24
0
ファイル: authenticator.py プロジェクト: xerosai/cf-one
import base64
import jwt
import mongoengine
import sys
import requests
from flask import _request_ctx_stack, jsonify, request
from functools import wraps
from werkzeug.local import LocalProxy
from app.app_config import AUTH0_KEY, AUTH0_AUDIENCE
from app.constants.response_constants import ResponseConstants as ReCon
from app.constants.route_constants import RouteConstants as RoCon
from app.non_db_models.action_response import ActionResponse
from app.models.user_profiles import UserProfiles

current_user = LocalProxy(lambda: _request_ctx_stack.top.current_user)


def authenticate(error):
    response = jsonify(error)
    response.status_code = 401
    return response


def requires_authentication(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.headers.get(RoCon.HTTP_HEADER_AUTH, None)
        response = ActionResponse(action_name='authenticate_api')

        if not auth:
コード例 #25
0
import logging
import os.path
from builtins import KeyError

import flask
from flask import Response as response
from flask import abort, redirect
from flask_mako import TemplateError, render_template
from werkzeug.exceptions import Forbidden as HTTPForbidden
from werkzeug.exceptions import Unauthorized as HTTPUnauthorized
from werkzeug.local import LocalProxy

log = logging.getLogger(__name__)

config = LocalProxy(lambda: flask.g.request_context['config'])

error_document_template = '''
    <html>
        <body>
            <p>An error occurred in %(prefix)s</p>
            <p>Error code: %(code)s</p>
            <p>%(message)s</p>
        </body>
    </html>
    '''


def url(controller, action=None):
    urlstr = '/{}/'.format(controller)
    if action != 'index' and action:
コード例 #26
0
from flask import current_app
from flask_caching import Cache
from flask_sqlalchemy import SQLAlchemy
from raven.contrib.flask import Sentry
from werkzeug.local import LocalProxy

cache = Cache(config={'CACHE_TYPE': 'simple'})
db = SQLAlchemy()
sentry = Sentry()

interpreter = LocalProxy(lambda: current_app.extensions['interpreter'])


def init_app(app):
    cache.init_app(app)
    db.init_app(app)
    sentry.init_app(app)
コード例 #27
0
    csrf_cookie_handler,
    default_want_json,
    get_config,
    hash_data,
    localize_callback,
    send_mail,
    string_types,
    url_for_security,
    verify_and_update_password,
    verify_hash,
)
from .views import create_blueprint, default_render_json
from .cache import VerifyHashCache

# Convenient references
_security = LocalProxy(lambda: current_app.extensions["security"])
local_cache = Local()

# List of authentication mechanisms supported.
AUTHN_MECHANISMS = ("basic", "session", "token")


#: Default Flask-Security configuration
_default_config = {
    "BLUEPRINT_NAME": "security",
    "CLI_ROLES_NAME": "roles",
    "CLI_USERS_NAME": "users",
    "URL_PREFIX": None,
    "SUBDOMAIN": None,
    "FLASH_MESSAGES": True,
    "I18N_DOMAIN": "flask_security",
コード例 #28
0
ファイル: proxies.py プロジェクト: topless/invenio-deposit
# -*- coding: utf-8 -*-
#
# This file is part of Invenio.
# Copyright (C) 2016-2019 CERN.
#
# Invenio is free software; you can redistribute it and/or modify it
# under the terms of the MIT License; see LICENSE file for more details.
"""Helper proxy to the state object."""

from __future__ import absolute_import, print_function

from flask import current_app
from werkzeug.local import LocalProxy

current_deposit = LocalProxy(lambda: current_app.extensions['invenio-deposit'])
"""Helper proxy to access state object."""
コード例 #29
0
import flask
from flask import Response, current_app, jsonify, redirect, request, \
    send_file, url_for
from flask_restful import Resource
from flask_restful.utils import cors
from werkzeug.local import LocalProxy
from werkzeug.utils import secure_filename

from .api import IIIFImageAPIWrapper
from .decorators import api_decorator, error_handler
from .signals import iiif_after_info_request, iiif_after_process_request, \
    iiif_before_info_request, iiif_before_process_request
from .utils import datetime_to_float, should_cache

current_iiif = LocalProxy(lambda: current_app.extensions['iiif'])


class IIIFImageBase(Resource):
    """IIIF Image Base."""
    def get(self, version, uuid):
        """Get IIIF Image Base.

        .. note::

            It will redirect to ``iiifimageinfo`` endpoint with status code
            303.
        """
        return redirect(url_for('iiifimageinfo', version=version, uuid=uuid),
                        code=303)
コード例 #30
0
ファイル: login.py プロジェクト: bsmr/tribe29-checkmk
            except MKAuthException:
                # Suppress cookie validation errors from other sites cookies
                auth_logger.debug('Exception while checking cookie %s: %s' %
                                  (cookie_name, traceback.format_exc()))
            except Exception:
                auth_logger.debug('Exception while checking cookie %s: %s' %
                                  (cookie_name, traceback.format_exc()))
    return None


def set_auth_type(_auth_type):
    # type: (str) -> None
    local.auth_type = _auth_type


auth_type = LocalProxy(lambda: local.auth_type)  # type: Union[str, LocalProxy]


@page_registry.register_page("login")
class LoginPage(Page):
    def __init__(self):
        # type: () -> None
        super(LoginPage, self).__init__()
        self._no_html_output = False

    def set_no_html_output(self, no_html_output):
        # type: (bool) -> None
        self._no_html_output = no_html_output

    def page(self):
        # type: () -> None
コード例 #31
0
ファイル: views.py プロジェクト: TerryKingston/schoolbloc
    def post(self):
        """ Create a new user """
        request_json = request.get_json(force=True)

        # Required args for all users
        try:
            username = request_json['username']
            password = request_json['password']
            role_type = request_json['role_type']
        except KeyError as e:
            abort(400, message="Missing required key: {}".format(e))

        # If it's a student
        if role_type == 'student':
            try:
                user_token = request_json['user_token']
            except KeyError as e:
                abort(400, message="Student missing required key: {}".format(e))

            try:
                student = Student.query.filter_by(user_token=user_token).one()
                existing_user = User.query.filter_by(id=student.user_id).first()
                if existing_user:
                    abort(400, message="This student already belongs to a user")
                user = User(username, password, role_type)
                db.session.add(user)
                db.session.flush()
                student.user_id = user.id
                db.session.add(student)
                db.session.commit()

                # Log the user in
                _jwt = LocalProxy(lambda: current_app.extensions['jwt'])
                identity = _jwt.authentication_callback(username, password)
                access_token = _jwt.jwt_encode_callback(identity)
                return _jwt.auth_response_callback(access_token, identity)
            except NoResultFound:
                abort(400, message="student user token not found")
            except IntegrityError:
                db.session.rollback()
                abort(400, message="Username already exists")

        # Add if it's a parent
        elif role_type == 'parent':
            try:
                first_name = request_json['first_name']
                last_name = request_json['last_name']
                email = request_json['email']
            except KeyError as e:
                abort(400, message="Parent missing required key: {}".format(e))

            try:
                user = User(username, password, role_type)
                db.session.add(user)
                db.session.flush()
                parent = Parent(user_id=user.id, first_name=first_name,
                                last_name=last_name, email=email)
                db.session.add(parent)
                db.session.commit()

                # Log the user in
                _jwt = LocalProxy(lambda: current_app.extensions['jwt'])
                identity = _jwt.authentication_callback(username, password)
                access_token = _jwt.jwt_encode_callback(identity)
                return _jwt.auth_response_callback(access_token, identity)
            except IntegrityError:
                db.session.rollback()
                abort(400, message="Username already exists")

        else:
            abort(400, message="Role type must be parent or student")
コード例 #32
0
    if DB_EXTENSION_KEY not in app.extensions:
        app.extensions[DB_EXTENSION_KEY] = db_session
        app.db = db_session       


    @app.teardown_appcontext
    def remove_db_session(exception=None):
        """Terminates all connections, transactions or stale, in session and checks them back into pool"""
        db_session.remove()


# A little too advanced maybe? skip?
def _get_db():
    """
    Returns
    -------
    sqlalchemy.orm.Session
        session obj stored in global Flask App.
    """
    if has_app_context():
        assert (
            DB_EXTENSION_KEY in current_app.extensions
        ), "`db_session` might not have been registered with the current app"
        return current_app.extensions[DB_EXTENSION_KEY]
    raise RuntimeError("No application context found.")



db = LocalProxy(_get_db)
コード例 #33
0
ファイル: __init__.py プロジェクト: tyctor/Flask-Store
Adds simple file handling for different providers to your application. Provides
the following providers out of the box:

* Local file storeage
* Amazon Simple File Storage (requires ``boto`` to be installed)
"""

from urllib.parse import urljoin

from flask import current_app, send_from_directory
from flask_store.exceptions import NotConfiguredError
from importlib import import_module
from werkzeug.local import LocalProxy

DEFAULT_PROVIDER = 'flask_store.providers.local.LocalProvider'
Provider = LocalProxy(lambda: store_provider())


def store_provider():
    """ Returns the default provider class as defined in the application
    configuration.

    Returns
    -------
    class
        The provider class
    """

    store = current_app.extensions['store']
    return store.store.Provider
コード例 #34
0
class ArticleForm(WebDepositForm):
    """Article form."""

    #
    # Fields
    #
    doi = fields.TextField(
        label=_("Digital Object Identifier"),
        placeholder=_("e.g. 10.1234/foo.bar..."),
        widget_classes="form-control",
        icon='fa fa-barcode fa-fw',
        validators=[
            doi_syntax_validator,
        ],
        filters=[
            strip_string,
            strip_prefixes("doi:", "http://dx.doi.org/"),
        ],
        processors=[
            missing_doi_warning,
        ],
    )

    publication_date = fields.Date(
        label=_('Publication date'),
        icon='fa fa-calendar fa-fw',
        description=_('Required. Format: YYYY-MM-DD.'),
        default=date.today(),
        validators=[validators.DataRequired()],
        widget=date_widget,
        widget_classes='input-sm',
        export_key='imprint.date',
    )

    title = fields.TextField(
        label=_('Title'),
        export_key='title.title',
        icon='fa fa-book fa-fw',
        widget_classes="form-control",
        validators=[validators.DataRequired()],
    )

    authors = fields.DynamicFieldList(
        fields.FormField(
            AuthorInlineForm,
            widget=ExtendedListWidget(
                item_widget=ItemWidget(),
                html_tag='div',
            ),
        ),
        label=_('Authors'),
        add_label=_('Add another author'),
        icon='fa fa-user fa-fw',
        min_entries=1,
        widget_classes='',
        export_key='authors',
        validators=[
            validators.DataRequired(),
            list_length(
                min_num=1,
                element_filter=filter_empty_helper(),
            )
        ],
    )

    abstract = fields.TextAreaField(
        label=_("Description"),
        description=_('Required.'),
        default='',
        icon='fa fa-pencil fa-fw',
        validators=[
            validators.DataRequired(),
        ],
        widget=CKEditorWidget(
            toolbar=[
                ['PasteText', 'PasteFromWord'],
                [
                    'Bold',
                    'Italic',
                    'Strike',
                    '-',
                    'Subscript',
                    'Superscript',
                ],
                ['NumberedList', 'BulletedList'],
                ['Undo', 'Redo', '-', 'Find', 'Replace', '-', 'RemoveFormat'],
                ['SpecialChar', 'ScientificChar'],
                ['Source'],
                ['Maximize'],
            ],
            disableNativeSpellChecker=False,
            extraPlugins='scientificchar',
            removePlugins='elementspath',
        ),
        filters=[
            sanitize_html(),
            strip_string,
        ],
        export_key='abstract.summary',
    )

    journal_title = fields.TextField(
        label=_("Journal title"),
        description=_("Optional."),
        validators=[
            required_if(
                'journal_volume',
                [
                    lambda x: bool(x.strip()),
                ],  # non-empty
                message=_("Journal title is required if you specify either "
                          "volume, issue or pages.")),
            required_if(
                'journal_issue',
                [
                    lambda x: bool(x.strip()),
                ],  # non-empty
                message=_("Journal title is required if you specify either "
                          "volume, issue or pages.")),
            required_if(
                'journal_pages',
                [
                    lambda x: bool(x.strip()),
                ],  # non-empty
                message=_("Journal title is required if you specify either "
                          "volume, issue or pages.")),
        ],
        export_key='journal_info.title',
        widget_classes='form-control',
    )

    journal_volume = fields.TextField(
        label=_("Volume"),
        description=_("Optional."),
        export_key='journal_info.volume',
        widget_classes='form-control',
    )

    journal_issue = fields.TextField(
        label=_("Issue"),
        description=_("Optional."),
        export_key='journal_info.issue',
        widget_classes='form-control',
    )

    journal_pages = fields.TextField(
        label=_("Pages"),
        description=_("Optional."),
        export_key='journal_info.pagination',
        widget_classes='form-control',
    )

    language = fields.SelectField(
        choices=LocalProxy(
            lambda: language_list_long(enabled_langs_only=False)),
        default='english',
        icon='fa fa-globe fa-fw',
        widget_classes='form-control',
    )

    keywords = fields.DynamicFieldList(
        fields.TextField(
            widget_classes='form-control',
            autocomplete=keywords_autocomplete,
            widget=ColumnInput(class_="col-xs-10"),
        ),
        label=_('Keywords'),
        add_label=_('Add another keyword'),
        icon='fa fa-tags fa-fw',
        widget_classes='',
        min_entries=1,
    )

    notes = fields.TextAreaField(
        label=_("Notes"),
        description=_('Optional.'),
        default='',
        validators=[validators.optional()],
        filters=[
            strip_string,
        ],
        widget_classes='form-control',
        icon='fa fa-pencil fa-fw',
        export_key='comment',
    )

    plupload_file = fields.FileUploadField(label="",
                                           widget=plupload_widget,
                                           export_key=False)

    #
    # Form configuration
    #
    _title = _('New article')
    _subtitle = _('Instructions: (i) Press "Save" to save your upload for '
                  'editing later, as many times you like. (ii) Upload or '
                  'remove  extra files in the bottom of the form. (iii) When '
                  'ready, press "Submit" to finalize your upload.')

    groups = [
        ('Basic Information', [
            'doi',
            'publication_date',
            'title',
            'authors',
            'abstract',
        ], {
            'indication': 'required',
        }),
        ('Journal',
         ['journal_title', 'journal_volume', 'journal_issue',
          'journal_pages'], {
              'indication': 'required'
          }),
        ('Additional information', ['language', 'keywords', 'notes'], {
            'indication': 'optional',
        })
    ]

    field_sizes = {
        'plupload_file': 'col-md-12',
    }
コード例 #35
0
def get_order_class():
    key = 'order'
    return LocalProxy(import_shop_object(key))
コード例 #36
0
ファイル: test_linting.py プロジェクト: te5in/CodeGra.de
def test_linters_permissions(teacher_user, student_user, test_client,
                             logged_in, assignment_real_works, request,
                             error_template, session, monkeypatch_celery):
    assignment, single_work = assignment_real_works
    linter, cfgs = 'Flake8', ''
    student_user2 = LocalProxy(
        session.query(m.User).filter_by(name="Student2").one)
    data = {'name': linter, 'cfg': cfgs}
    assig_id = assignment.id

    with logged_in(student_user):
        test_client.req(
            'post',
            f'/api/v1/assignments/{assig_id}/linter',
            403,
            data=data,
            result=error_template,
        )
    with logged_in(teacher_user):
        test_client.req(
            'post',
            f'/api/v1/assignments/{assig_id}/linter',
            200,
            data=data,
        )
    with logged_in(student_user):
        test_client.req(
            'get',
            f'/api/v1/assignments/{assig_id}/linters/',
            403,
            result=error_template,
        )

    code_id = session.query(m.File.id).filter(
        m.File.work_id == single_work['id'],
        m.File.parent != None,  # NOQA
        m.File.name != '__init__.py',
    ).first()[0]
    with logged_in(student_user):
        test_client.req(
            'get',
            f'/api/v1/code/{code_id}',
            200,
            query={'type': 'linter-feedback'},
        )
    with logged_in(student_user2):
        # Other student cannot view linter feedback
        test_client.req(
            'get',
            f'/api/v1/code/{code_id}',
            403,
            query={'type': 'linter-feedback'},
        )

    with logged_in(teacher_user):
        linter_result = test_client.req(
            'get',
            f'/api/v1/assignments/{assig_id}/linters/',
            200,
        )
    assert any('id' in l for l in linter_result)

    with logged_in(student_user):
        for linter in linter_result:
            if 'id' not in linter:
                continue
            test_client.req(
                'delete',
                f'/api/v1/linters/{linter["id"]}',
                403,
                result=error_template,
            )
    with logged_in(teacher_user):
        for linter in linter_result:
            if 'id' not in linter:
                continue
            test_client.req(
                'get',
                f'/api/v1/linters/{linter["id"]}',
                200,
            )
コード例 #37
0
    Alternatively return :class:`~flask.Flask` application object when no
    blueprint is activated during request.
    """
    return current_app.blueprints.get(request.blueprint,
                                      current_app._get_current_object())  # pylint: disable=W0212


def _lookup_breadcrumb_root_path():
    """Backend function for breadcrumb_root_path proxy."""
    return current_app.config.get('BREADCRUMBS_ROOT')


# Proxies
# pylint: disable-msg=C0103

#: A proxy for the current function.
current_function = LocalProxy(_lookup_current_function)

#: A proxy for the current blueprint or application object.
current_blueprint = LocalProxy(_lookup_current_blueprint)

#: A proxy for breadcrumbs root element path.
breadcrumb_root_path = LocalProxy(_lookup_breadcrumb_root_path)

#: A proxy for detecting current breadcrumb path.
current_path = LocalProxy(Breadcrumbs.current_path)

#: A proxy for current breadcrumbs list.
current_breadcrumbs = LocalProxy(Breadcrumbs.breadcrumbs)
# pylint: enable-msg=C0103
コード例 #38
0
# Copyright (C) 2018 CERN.
#
# Zenodo is free software; you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of the
# License, or (at your option) any later version.
#
# Zenodo is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Zenodo; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
# MA 02111-1307, USA.
#
# In applying this license, CERN does not
# waive the privileges and immunities granted to it by virtue of its status
# as an Intergovernmental Organization or submit itself to any jurisdiction.
"""Proxies for Zenodo stats module."""

from __future__ import absolute_import, print_function

from flask import current_app
from werkzeug.local import LocalProxy

current_stats_search_client = LocalProxy(
    lambda: current_app.extensions['zenodo-stats'].search_client)
"""Proxy to Elasticsearch client used for statistics queries."""
コード例 #39
0
            self.ratelimit["storage_url"] = self.app.redis_url

    def get_flask_dict(self):
        flattened = {}
        for cpk in ["cache", "mail", "sendgrid", "app", "ratelimit"]:
            if cpk in self.keys():
                for i in self[cpk]:
                    if cpk == "app":
                        key = i.upper()
                    else:
                        key = "{}_{}".format(cpk, i).upper()
                    flattened[key] = self[cpk][i]

        # These values are used by flask-cloudy.
        for key in [
                "provider", "key", "secret", "container", "server",
                "server_url"
        ]:
            if key in self.storage:
                flattened[f"STORAGE_{key}".upper()] = self.storage[key]
        return flattened


def ensure_trailing_slash(d, key):
    """ Add a slash to the end of a dictionary entry if it doesn't already have one. """
    if key in d and d[key] and d[key][-1] != "/":
        d[key] = d[key] + "/"


config = LocalProxy(lambda: current_app.config["THROAT_CONFIG"])
コード例 #40
0
ファイル: core.py プロジェクト: jjuhn/lims
from flask_principal import Principal, RoleNeed, UserNeed, Identity, \
    identity_loaded
from itsdangerous import URLSafeTimedSerializer
from passlib.context import CryptContext
from werkzeug.datastructures import ImmutableList
from werkzeug.local import LocalProxy
from werkzeug.security import safe_str_cmp

from .utils import config_value as cv, get_config, md5, url_for_security, string_types
from .views import create_blueprint
from .forms import LoginForm, ConfirmRegisterForm, RegisterForm, \
    ForgotPasswordForm, ChangePasswordForm, ResetPasswordForm, \
    SendConfirmationForm, PasswordlessLoginForm

# Convenient references
_security = LocalProxy(lambda: current_app.extensions['security'])


#: Default Flask-Security configuration
_default_config = {
    'BLUEPRINT_NAME': 'security',
    'URL_PREFIX': None,
    'SUBDOMAIN': None,
    'FLASH_MESSAGES': True,
    'PASSWORD_HASH': 'plaintext',
    'PASSWORD_SALT': None,
    'LOGIN_URL': '/login',
    'LOGOUT_URL': '/logout',
    'REGISTER_URL': '/register',
    'RESET_URL': '/reset',
    'CHANGE_URL': '/change',
コード例 #41
0
ファイル: utils.py プロジェクト: gothm/flask-security
from flask import url_for, flash, current_app, request, session, redirect, \
     render_template
from flask.ext.login import login_user as _login_user, \
     logout_user as _logout_user
from flask.ext.principal import Identity, AnonymousIdentity, identity_changed
from werkzeug.local import LocalProxy

from .core import current_user
from .signals import user_registered, reset_password_instructions_sent, \
     login_instructions_sent


# Convenient references
_security = LocalProxy(lambda: current_app.extensions['security'])

_datastore = LocalProxy(lambda: _security.datastore)

_pwd_context = LocalProxy(lambda: _security.pwd_context)

_logger = LocalProxy(lambda: current_app.logger)


def anonymous_user_required(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        if current_user.is_authenticated():
            return redirect(get_url(_security.post_login_view))
        return f(*args, **kwargs)
    return wrapper

コード例 #42
0
ファイル: extensions.py プロジェクト: estevaocs/acttivebi
    def parse_manifest_json(self) -> None:
        try:
            with open(self.manifest_file, "r") as f:
                # the manifest includes non-entry files we only need entries in
                # templates
                full_manifest = json.load(f)
                self.manifest = full_manifest.get("entrypoints", {})
        except Exception:  # pylint: disable=broad-except
            pass

    def get_manifest_files(self, bundle: str, asset_type: str) -> List[str]:
        if self.app and self.app.debug:
            self.parse_manifest_json()
        return self.manifest.get(bundle, {}).get(asset_type, [])


APP_DIR = os.path.dirname(__file__)
appbuilder = AppBuilder(update_perms=False)
cache_manager = CacheManager()
celery_app = celery.Celery()
db = SQLA()
_event_logger: dict = {}
event_logger = LocalProxy(lambda: _event_logger.get("event_logger"))
feature_flag_manager = FeatureFlagManager()
jinja_context_manager = JinjaContextManager()
manifest_processor = UIManifestProcessor(APP_DIR)
migrate = Migrate()
results_backend_manager = ResultsBackendManager()
security_manager = LocalProxy(lambda: appbuilder.sm)
talisman = Talisman()
コード例 #43
0
ファイル: __init__.py プロジェクト: bopopescu/Movie
from werkzeug.local import LocalProxy
from functools import wraps
from flask import (session, current_app, request, has_request_context, _request_ctx_stack)

from flask_login.signals import user_logged_in, user_login_confirmed, user_logged_out
from flask_login.config import COOKIE_NAME, EXEMPT_METHODS

current_user = LocalProxy(lambda: _get_user())


def _get_endpoint():
    endpoint = request.endpoint
    try:
        return endpoint.split('.')[0]
    except Exception as e:
        return 'user'


def login_user(user, remember=False, duration=None, force=False, fresh=True):
    if not force and not user.is_active:
        return False

    user_id = getattr(user, current_app.login_manager.id_attribute)()
    session[_get_endpoint() + '_user_id'] = user_id
    session[_get_endpoint() + '_fresh'] = fresh
    # 存放浏览器和ip加密信息
    session[_get_endpoint() + '_id'] = current_app.login_manager._session_identifier_generator()
    if remember:
        session[_get_endpoint() + '_remember'] = 'set'
        if duration is not None:
            try:
コード例 #44
0
        write concern timeout limit to 2500 milliseconds.
        """

        db = g._database = MongoClient(
            MFLIX_DB_URI,
            # TODO: Connection Pooling
            # Set the maximum connection pool size to 50 active connections.
            maxPoolSize=50,
            # TODO: Timeouts
            # Set the write timeout limit to 2500 milliseconds.
            wTimeoutMS=2500)[MFLIX_DB_NAME]
    return db


# Use LocalProxy to read the global db instance with just `db`
db = LocalProxy(get_db)


def get_movies_by_country(countries):
    """
    Finds and returns movies by country.
    Returns a list of dictionaries, each dictionary contains a title and an _id.
    """
    try:
        """
        Ticket: Projection

        Write a query that matches movies with the countries in the "countries"
        list, but only returns the title and _id of each movie.

        Remember that in MongoDB, the $in operator can be used with a list to
コード例 #45
0
ファイル: business_filings.py プロジェクト: kialj876/lear
    def _save_filing(
        client_request: LocalProxy,  # pylint: disable=too-many-return-statements,too-many-branches
        business_identifier: str,
        user: User,
        filing_id: int
    ) -> Tuple[Union[Business, RegistrationBootstrap], Filing, dict, int]:
        """Save the filing to the ledger.

        If not successful, a dict of errors is returned.

        Returns: {
            Business: business model object found for the identifier provided
            Filing: filing model object for the submitted filing
            dict: a dict of errors
            int: the HTTPStatus error code

        @TODO refactor to a set of single putpose routines
        }
        """
        json_input = client_request.get_json()
        if not json_input:
            return None, None, {'message':
                                f'No filing json data in body of post for {business_identifier}.'}, \
                HTTPStatus.BAD_REQUEST

        if business_identifier.startswith('T'):
            # bootstrap filing
            bootstrap = RegistrationBootstrap.find_by_identifier(
                business_identifier)
            business = None
            if not bootstrap:
                return None, None, {
                    'message': f'{business_identifier} not found'
                }, HTTPStatus.NOT_FOUND
            if client_request.method == 'PUT':
                rv = db.session.query(Filing). \
                    filter(Filing.temp_reg == business_identifier). \
                    filter(Filing.id == filing_id). \
                    one_or_none()
                if not rv:
                    return None, None, {
                        'message': f'{business_identifier} no filings found'
                    }, HTTPStatus.NOT_FOUND
                filing = rv
            else:
                filing = Filing()
                filing.temp_reg = bootstrap.identifier
                if not json_input['filing'].get('business'):
                    json_input['filing']['business'] = {}
                json_input['filing']['business'][
                    'identifier'] = bootstrap.identifier

        else:
            # regular filing for a business
            business = Business.find_by_identifier(business_identifier)
            if not business:
                return None, None, {
                    'message': f'{business_identifier} not found'
                }, HTTPStatus.NOT_FOUND

            if client_request.method == 'PUT':
                rv = db.session.query(Business, Filing). \
                    filter(Business.id == Filing.business_id). \
                    filter(Business.identifier == business_identifier). \
                    filter(Filing.id == filing_id). \
                    one_or_none()
                if not rv:
                    return None, None, {
                        'message': f'{business_identifier} no filings found'
                    }, HTTPStatus.NOT_FOUND
                filing = rv[1]
            else:
                filing = Filing()
                filing.business_id = business.id

        try:
            filing.submitter_id = user.id
            filing.filing_json = json_input
            filing.source = filing.filing_json['filing']['header'].get(
                'source', Filing.Source.LEAR.value)
            if filing.source == Filing.Source.COLIN.value:
                try:
                    filing.filing_date = datetime.datetime.fromisoformat(
                        filing.filing_json['filing']['header']['date'])
                    for colin_id in filing.filing_json['filing']['header'][
                            'colinIds']:
                        colin_event_id = ColinEventId()
                        colin_event_id.colin_event_id = colin_id
                        filing.colin_event_ids.append(colin_event_id)
                except KeyError:
                    current_app.logger.error(
                        'Business:%s missing filing/header values, unable to save',
                        business.identifier)
                    return None, None, {
                        'message': 'missing filing/header values'
                    }, HTTPStatus.BAD_REQUEST
            else:
                filing.filing_date = datetime.datetime.utcnow()

            # for any legal type, set effective date as set in json; otherwise leave as default
            filing.effective_date = \
                datetime.datetime.fromisoformat(filing.filing_json['filing']['header']['effectiveDate']) \
                if filing.filing_json['filing']['header'].get('effectiveDate', None) else datetime.datetime.utcnow()

            filing.save()
        except BusinessException as err:
            return None, None, {'error': err.error}, err.status_code

        return business or bootstrap, filing, None, None
コード例 #46
0
def insert_record(query, args=()):
    local_proxy_db = LocalProxy(get_db)
    local_proxy_db.execute(query, args)
    local_proxy_db.commit()
    return
コード例 #47
0
ファイル: __init__.py プロジェクト: techniq/flask-security
class RoleCreationError(Exception):
    """Raised when an error occurs when creating a role
    """
    
         
#: App logger for convenience
logger = LocalProxy(lambda: current_app.logger)

#: Authentication provider
auth_provider = LocalProxy(lambda: current_app.auth_provider)

#: Login manager
login_manager = LocalProxy(lambda: current_app.login_manager)

#: Password encyption context
pwd_context = LocalProxy(lambda: current_app.pwd_context)

#: User datastore
user_datastore = LocalProxy(lambda: getattr(current_app, 
    current_app.config[USER_DATASTORE_KEY]))

def roles_required(*args):
    """View decorator which specifies that a user must have all the specified
    roles. Example::
        
        @app.route('/dashboard')
        @roles_required('admin', 'editor')
        def dashboard():
            return 'Dashboard'
            
    The current user must have both the `admin` role and `editor` role in order
コード例 #48
0
        for el in google_objects, twitter_objects:
            log.debug(el)

    return google_objects, twitter_objects


def get_interested_identities():
    objects = getattr(g, 'objects', None)
    if objects is None:
        objects = g.objects = load_interested_identities(
            open(g_identities_source_path, 'r'),
            open(t_identities_source_path, 'r'))
    return objects


interested_identities = LocalProxy(get_interested_identities)


@app.route('/')
def main():
    state = ''.join(
        random.choice(string.ascii_uppercase + string.digits)
        for _ in xrange(32))
    session['state'] = state
    return render_template('main.html',
                           GOOGLE_CLIENT_ID=GOOGLE_CLIENT_ID,
                           STATE=state)


@app.route('/ttr_auth', methods=['POST', 'GET'])
def ttr_auth():