Ejemplo n.º 1
0
def try_to_eval(string, context={}, **general_context):
    """Take care of evaluating the python expression.

    If an exception happens, it tries to import the needed module.

    @param string: String to evaluate
    @param context: Context needed, in some cases, to evaluate the string

    @return: The value of the expression inside string
    """
    if not string:
        return None

    res = None
    imports = []
    general_context.update(context)
    simple = False
    while True:
        try:
            # kwalitee: disable=eval
            res = eval(string, globals().update(general_context), locals())
        except NameError as err:
            #Try first to import using werkzeug import_string
            try:
                from werkzeug.utils import import_string
                if "." in string:
                    part = string.split('.')[0]
                    import_string(part)
                    for i in string.split('.')[1:]:
                        part += '.' + i
                        import_string(part)
                    continue
                else:
                    simple = True
            except:
                pass

            import_name = str(err).split("'")[1]
            if import_name not in imports:
                if import_name in context:
                    globals()[import_name] = context[import_name]
                else:
                    globals()[import_name] = __import__(import_name)
                    imports.append(import_name)
                continue
            elif simple:
                import_name = str(err).split("'")[0]
                if import_name in context:
                    globals()[import_name] = context[import_name]
                else:
                    globals()[import_name] = __import__(import_name)
                    imports.append(import_name)
                continue

            raise ImportError("Can't import the needed module to evaluate %s"
                              (string, ))
        import os
        if isinstance(res, type(os)):
            raise ImportError
        return res
Ejemplo n.º 2
0
    def _get_search_results(self, q):
        from flask_cms.app import app

        results = {}
        searchable_models = app.config.get("SEARCHABLE_MODELS", [])
        for model in searchable_models:
            model_string = model[0]
            model_class = import_string(model_string)

            # Only get these columns from db
            columns_to_select = model[2]
            entities = [import_string("{}.{}".format(model_string, column))
                        for column in columns_to_select]

            # build search condition
            searchable_columns = model[1]
            column_objs = [import_string("{}.{}".format(model_string, column))
                           for column in searchable_columns]
            search_condition = [obj.like("%{}%".format(q))
                                for obj in column_objs]

            # query model with entities for search condition
            model_results = (model_class.query.
                             with_entities(*entities).
                             filter(or_(*search_condition)).
                             params(q=q).all())
            if model_results:
                results[model_class.__tablename__] = model_results
        return results
Ejemplo n.º 3
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])

    db.init_app(app)
    csrf.init_app(app)
    bcrypt.init_app(app)
    mail.init_app(app)
    login_manager.init_app(app)
    redis_store.init_app(app)
    celery.conf.update(app.config)

    models_committed.connect(receive_change, app)

    sign_in_manage = {}
    sign_in_func = 'account.sign_in'
    for path in blueprints:
        bp = import_string('sayit.views.' + path[0])
        app.register_blueprint(bp, url_prefix=path[1])
        sign_in_manage[bp.name] = sign_in_func

    for path in jinja_filters:
        flt = import_string('sayit.filters:' + path[0])
        app.jinja_env.filters[path[1]] = flt

    login_manager.blueprint_login_views = sign_in_manage

    return app
Ejemplo n.º 4
0
def import_module_from_packages(name, app=None, packages=None, silent=False):
    """Import modules from packages."""
    warnings.warn("Use of import_module_from_packages has been deprecated."
                  " Please use Flask-Registry instead.",  DeprecationWarning)

    if app is None and has_app_context():
        app = current_app
    if app is None:
        raise Exception(
            'Working outside application context or provide app'
        )

    if packages is None:
        packages = app.config.get('PACKAGES', [])

    for package in packages:
        if package.endswith('.*'):
            for module in find_modules(package[:-2], include_packages=True):
                try:
                    yield import_string(module + '.' + name, silent)
                except ImportError:
                    pass
                except Exception:
                    app.logger.exception("could not import %s.%s",
                                         package, name)
            continue
        try:
            yield import_string(package + '.' + name, silent)
        except ImportError:
            pass
        except Exception:
            app.logger.exception("could not import %s.%s", package, name)
Ejemplo n.º 5
0
def main(entrypoint, adapter, host, port, debug, level):
    if '.' not in sys.path:
        sys.path.insert(0, '.')

    # Get the API object
    api = import_string(entrypoint)
    if not isinstance(api, RESTArt):
        raise RuntimeError(
            'The object specified by entrypoint %r is not an '
            'instance of `restart.api.RESTArt`' % str(entrypoint)
        )

    # Get the adapter class
    adapter_class = import_string(adapter)
    if not issubclass(adapter_class, Adapter):
        raise RuntimeError(
            'The class specified by adapter %r is not a subclass '
            'of `restart.adapter.Adapter`' % str(adapter)
        )

    # Change the level of the global logger
    from .logging import global_logger
    global_logger.setLevel(level)

    # Run the API as a service
    service = Service(api, adapter_class)
    service.run(host, port, debug)
Ejemplo n.º 6
0
    def _discover_module(self, pkg):
        import_str = pkg + '.' + self.module_name

        blacklist = self.app.config.get(
            '%s_%s_EXCLUDE' % (self.cfg_var_prefix, self.module_name.upper()),
            []
        )

        try:
            import_string(import_str, silent=self.silent)
        except ImportError as e:  # pylint: disable=C0103
            self._handle_importerror(e, pkg, import_str)
            return
        except SyntaxError as e:
            self._handle_syntaxerror(e, pkg, import_str)
            return

        for m in find_modules(import_str):
            if m in blacklist:  # Exclude specific package
                continue
            try:
                module = import_string(m, silent=self.silent)
                if module is not None:
                    self.register(module)
            except ImportError as e:  # pylint: disable=C0103
                self._handle_importerror(e, import_str, m)
            except SyntaxError as e:
                self._handle_syntaxerror(e, import_str, m)
Ejemplo n.º 7
0
    def autodiscover(self, paths, models=None, module_names=None):
        """
        Automatically register all Kibble views under ``path``.

        :param paths: The module paths to search under.
        :param module_names: A list of module names to match on. e.g. `kibble`
            will only attempt to autodiscover `kibble.py` files.
        :param models: A list of model kinds (either a ``ndb.Model`` subclass
            or a string) (Optional)
        """
        from werkzeug.utils import find_modules, import_string
        from .base import KibbleMeta

        all_models = models is None
        models = [
            (x._kind() if isinstance(x, ndb.Model) else x)
            for x in models or []]

        for p in paths:
            for mod in find_modules(p, True, True):
                # logger.debug("Autodiscover: %s", mod)
                if module_names is None \
                        or mod.rsplit('.', 1)[-1] in module_names:
                    import_string(mod)

        for view in KibbleMeta._autodiscover:
            if view.model and (all_models or view.kind() in models):
                self.register_view(view)
Ejemplo n.º 8
0
def import_module_from_packages(name, app=None, packages=None, silent=False):
    if packages is None:
        if app is None and has_app_context():
            app = current_app
        if app is None:
            raise Exception(
                'Working outside application context or provide app'
            )
        #FIXME
        packages = app.config.get('PACKAGES', [])

    for package in packages:
        if package.endswith('.*'):
            for module in find_modules(package[:-2], include_packages=True):
                try:
                    yield import_string(module + '.' + name, silent)
                except ImportError:
                    pass
                except Exception as e:
                    import traceback
                    traceback.print_exc()
                    app.logger.error('Could not import: "%s.%s: %s',
                                     module, name, str(e))
                    pass
            continue
        try:
            yield import_string(package + '.' + name, silent)
        except ImportError:
            pass
        except Exception as e:
            import traceback
            traceback.print_exc()
            app.logger.error('Could not import: "%s.%s: %s',
                             package, name, str(e))
            pass
Ejemplo n.º 9
0
def serializer(metadata_prefix):
    """Return etree_dumper instances."""
    metadataFormats = current_app.config['OAISERVER_METADATA_FORMATS']
    serializer_ = metadataFormats[metadata_prefix]['serializer']
    if isinstance(serializer_, tuple):
        return partial(import_string(serializer_[0]), **serializer_[1])
    return import_string(serializer_)
Ejemplo n.º 10
0
def test_import_string_attribute_error():
    with pytest.raises(AttributeError) as foo_exc:
        utils.import_string('tests.res.foo')
    assert 'screw your import' in str(foo_exc)

    with pytest.raises(AttributeError) as bar_exc:
        utils.import_string('tests.res.bar')
    assert 'screw your import' in str(bar_exc)
Ejemplo n.º 11
0
 def __init__(self):
   # avoid 'no implementation for kind' error.
   import_string(settings.AUTH_USER_MODEL)
   if not 'kay.sessions.middleware.SessionMiddleware' in \
         settings.MIDDLEWARE_CLASSES:
     raise ImproperlyConfigured(
       "The DatastoreBackend requires session middleware to "
       "be installed. Edit your MIDDLEWARE_CLASSES setting to insert "
       "'kay.sessions.middleware.SessionMiddleware'.")
Ejemplo n.º 12
0
def run(*args):
    # XXX: Need to import here before manager is run to ensure additional
    # commands are registered
    for mod in 'account', 'video':
        import_string('wonder.romeo.%s.commands' % mod)

    if args:
        return manager.handle(sys.argv[0], args)
    else:
        return manager.run()
Ejemplo n.º 13
0
    def init_app(self, app, elasticsearch=None):
        """Flask application initialization."""
        self.init_config(app)
        # Configure elasticsearch client.
        self._clients[app] = elasticsearch

        for autoindex in app.config.get('SEARCH_AUTOINDEX', []):
            import_string(autoindex)

        app.cli.add_command(index_cmd)
        app.extensions['invenio-search'] = self
Ejemplo n.º 14
0
def test_import_string_attribute_error(tmpdir, monkeypatch):
    monkeypatch.syspath_prepend(str(tmpdir))
    tmpdir.join('foo_test.py').write('from bar_test import value')
    tmpdir.join('bar_test.py').write('raise AttributeError("screw you!")')
    with pytest.raises(AttributeError) as foo_exc:
        utils.import_string('foo_test')
    assert 'screw you!' in str(foo_exc)

    with pytest.raises(AttributeError) as bar_exc:
        utils.import_string('bar_test')
    assert 'screw you!' in str(bar_exc)
Ejemplo n.º 15
0
def init_tasks(app):
    """
    Extracts modules (task types) from global configuration

    :param app: Current Flask application instance
    :type app: Flask.Flask

    :return: Dictionary with instantiated *TaskType objects
    :rtype: dict
    """
    task_types = {}
    loaders = {}
    enabled_tasks = app.config.get("ENABLED_TASKS", {})

    for plugin, task in enabled_tasks.iteritems():
        task_settings = import_string(
            "{plugin_name}.settings".format(plugin_name=plugin)
        )
        plugin_instance = import_string(
            "{plugin_name}".format(plugin_name=plugin))
        settings = plugin_instance.configure(task_settings)

        task_instance = import_string(
            "{plugin_name}.models.task_types.{task}".format(
                plugin_name=plugin, task=task)
        )
        static_path = import_string(plugin).__path__[0]

        js_name = 'plugin_js_{task}'.format(task=task_instance.type_name)
        css_name = 'plugin_css_{task}'.format(task=task_instance.type_name)

        if len(task_instance.JS_ASSETS) > 0:
            js = Bundle(*map(lambda x: os.path.join(static_path, x),
                             task_instance.JS_ASSETS),
                        output="scripts/{name}.js".format(name=js_name),
                        filters=app.config.get('JS_ASSETS_FILTERS', ''))
            app.assets.register(js_name, js)

        if len(task_instance.CSS_ASSETS) > 0:
            css = Bundle(*map(lambda x: os.path.join(static_path, x),
                              task_instance.CSS_ASSETS),
                         output="styles/{name}.css".format(name=css_name),
                         filters=app.config.get('CSS_ASSETS_FILTERS', ''))

            app.assets.register(css_name, css)

        loaders[task_instance.type_name] = jinja2.PackageLoader(plugin)
        task_types[task_instance.type_name] = task_instance(settings=settings)

    app.jinja_loader = jinja2.ChoiceLoader([
        app.jinja_loader,
        jinja2.PrefixLoader(loaders)])

    return task_types
Ejemplo n.º 16
0
    def add_blueprint(self, name, kw):
        join_name = lambda n, s: '%s.%s' % (n, s)

        for module in self.config['LOAD_MODULES_EXTENSIONS']:
            try:
                import_string(join_name(name, module))
            except (ImportError, AttributeError):
                # print 'No {e_module} found in {e_name}.'.format(e_module=module, e_name=name)
                pass

        blueprint = import_string(join_name(name, 'app'))
        self.register_blueprint(blueprint, **kw)
Ejemplo n.º 17
0
 def record_file_factory(self):
     """Load default storage factory."""
     imp = self.app.config.get("FILES_REST_RECORD_FILE_FACTORY")
     if imp:
         import_string(imp)
     else:
         try:
             get_distribution('invenio-records-files')
             from invenio_records_files.utils import record_file_factory
             return record_file_factory
         except DistributionNotFound:
             return lambda pid, record, filename: None
Ejemplo n.º 18
0
def register_blueprint(app, app_package, module_name="app", blueprint_name="module", on_error=None):
    """Automatically load Blueprint from the specified package and registers them with Flask."""

    #TODO: simplify for our case

    if not app_package:
        raise ValueError("No apps package provided - unable to begin autoload")

    if isinstance(app_package, basestring):
        package_code = import_string(app_package)
    else:
        #: `apps_package` can be the already imported parent package
        #: (i.e. the following is a licit pattern)::
        #:
        #:      import app_package
        #:      # do something else with app_package
        #:      autoload(app, app_package)
        package_code = app_package
        app_package = app_package.__name__

    package_paths = package_code.__path__

    package_paths = [path.join(path.dirname(app.root_path), p) for p in package_paths]
    root = app_package
    app_package = app_package + u"." if not app_package.endswith(".") else app_package

    if on_error is None:
        on_error = lambda name: app.logger.warn("Unable to import {name}.".format(name=name))

    _to_import = "{base}.{module}.{symbol}"
    import_template = lambda base: _to_import.format(base=base,
                                                     module=module_name,
                                                     symbol=blueprint_name)

    #: Autoloaded apps must be Python packages
    #: The root of the package is ONLY inspected for a routing file
    package_contents = [[None, root, True]]
    for _, sub_app_name, is_pkg in package_contents:

        if not is_pkg:
            continue

        sub_app_import_path = import_template(base=sub_app_name)
        sub_app = import_string(sub_app_import_path)

        if isinstance(sub_app, Blueprint):
            app.register_blueprint(sub_app, url_prefix='/%s' % sub_app.name)
            # TODO: Check if it's necessary to import_models
            import_models(app, sub_app_name)
        else:
            app.logger.warn(("Failed to register {name} - "
                             "it does not match the registration pattern.").format(name=sub_app_name))
Ejemplo n.º 19
0
def create_app():
    app = Flask(__name__)
    app.config.from_object('envcfg.json.envision')

    for extension_name in extensions:
        extension = import_string(extension_name)
        extension.init_app(app)

    for blueprint_name in blueprints:
        blueprint = import_string(blueprint_name)
        app.register_blueprint(blueprint)

    return app
Ejemplo n.º 20
0
def general_menu():
    menu_items = list()
    blueprints = app.blueprints
    for k, v in blueprints.items():
        try:
            config = import_string('%s.config' % import_string(v.import_name).__package__)
        except ImportError, e:
            print e
        else:
            if hasattr(config, 'RUS_NAME'):
                menu_items.append(dict(module=v.name, name=config.RUS_NAME))
            else:
                menu_items.append(dict(module=v.name, name=v.name))
Ejemplo n.º 21
0
def import_tests(apps_path):
    pkg_list = os.listdir(apps_path)
    base_pkg = os.path.basename(apps_path)
    test_pkgs = list()
    if pkg_list:
        for pkg_path in pkg_list:
            if os.path.isdir(os.path.join(apps_path, pkg_path)):
                if os.path.isdir(os.path.join(apps_path, pkg_path, 'tests')):
                    for _test_pkg in os.listdir(os.path.join(apps_path, pkg_path, 'tests')):
                        test_pkgs.append(import_string('%s.%s.tests.%s' %
                                                       (base_pkg, pkg_path, os.path.splitext(_test_pkg)[0])))
                else:
                    test_pkgs.append(import_string('%s.%s.tests' % (base_pkg, pkg_path)))
    return test_pkgs
Ejemplo n.º 22
0
def send_registration_confirm(request, registration_key):
  from kay.registration.models import RegistrationProfile
  import_string(settings.AUTH_USER_MODEL)
  p = db.get(registration_key)
  subject = render_to_string('registration/activation_email_subject.txt',
                             {'appname': settings.APP_NAME})
  subject = ''.join(subject.splitlines())
  message = render_to_string(
    'registration/activation_email.txt',
    {'activation_key': registration_key,
     'appname': settings.APP_NAME})
  mail.send_mail(subject=subject, body=message,
                 sender=settings.DEFAULT_MAIL_FROM, to=p.parent().email)
  return Response("OK")
Ejemplo n.º 23
0
def _get_records(kevent):
    """Unpack records from a Kinesis event."""
    events, shard_id = utils.unpack_kinesis_event(
        kevent,
        deserializer="{{kinesis_deserializer}}" \
                and "{{kinesis_desearializer}}" != "None" \
                and import_string("{{kinesis_deserializer}}"),
        unpacker="{{kinesis_unpacker}}" \
                and "{{kinesis_unpacker}}" != "None" \
                and import_string("{{kinesis_unpacker}}"),
        embed_timestamp="{{received_at_field}}"
        )

    return events, shard_id
Ejemplo n.º 24
0
def runscript(script_path):
    '''
    Run Function. e.g.:
    cheapflight.scripts.rader:main or
    cheapflight/scripts/rader.py with main()
    '''
    if ":" not in script_path:
        script_path = os.path.expanduser(os.path.expandvars(script_path))
        script_path = os.path.relpath(script_path)
        script_path = script_path.rstrip(".py")
        script_path = script_path.replace(os.path.sep, ".")
        script_path = script_path.lstrip(".")
        script_path = "%s:main" % script_path

    import_string(script_path)()
Ejemplo n.º 25
0
 def __call__(self):
     try:
         endpoint = self.endpoint
     except NotFound:
         return super(URLMapAdapterMixin, self).__call__()
     endpoint = import_string(endpoint)
     return self.application.dispatch_to_endpoint(self, endpoint)
Ejemplo n.º 26
0
def main():
    parser = ArgumentParser(description=__doc__)
    parser.add_argument('app_module',
                        metavar='APP_MODULE',
                        help='Python importible flask application e.g. my.module:app')
    parser.add_argument('-u', '--username', required=True,
                        help='Ldap login with this username')
    parser.add_argument('-p', '--password', required=True,
                        help='Ldap login with this password')
    args = parser.parse_args()

    if ':' in args.app_module:
        import_name, appname = args.app_module.split(':', 1)
    else:
        import_name, appname = args.app_module, 'app'

    module = import_string(import_name)
    app = getattr(module, appname)

    userdata = app.ldap_login_manager.ldap_login(args.username, args.password)
    if userdata is None:
        print "Invalid username/password"
    else:
        print "Got userdata for %s" % args.username
        pprint(userdata)
Ejemplo n.º 27
0
def setup_app(app):
    """Initialize Flask-Security."""
    app.config.setdefault('SECURITY_DATASTORE_FACTORY', None)
    app.config.setdefault('SECURITY_CHANGEABLE', True)
    app.config.setdefault('SECURITY_CONFIRMABLE', True)
    app.config.setdefault('SECURITY_PASSWORD_HASH', 'pbkdf2_sha512')
    app.config.setdefault('SECURITY_RECOVERABLE', True)
    app.config.setdefault('SECURITY_REGISTERABLE', True)
    app.config.setdefault('SECURITY_TRACKABLE', True)
    app.config.setdefault('SECURITY_LOGIN_WITHOUT_CONFIRMATION', True)

    # Get datastore factory method
    create_datastore = import_string(app.config.get(
        'SECURITY_DATASTORE_FACTORY'))

    if create_datastore is None:
        raise RuntimeError("Please specify SECURITY_DATASTORE_FACTORY")

    datastore = create_datastore(app)

    # Create user datastore and initialize extension.
    state = security.init_app(app, datastore=datastore)

    # Use Celery task for sending emails.
    @state.send_mail_task
    def delay_security_email(msg):
        send_security_email.delay(msg)
Ejemplo n.º 28
0
def _upgrade_recipe_find_path(import_str, create=True):
    """Determine repository name and path for new upgrade.

    It is based on package import path.
    """
    try:
        # Import package
        m = import_string(import_str)

        # Check if package or module
        if m.__package__ is not None and m.__package__ != m.__name__:
            raise RuntimeError(
                "Expected package but found module at '%s'." % import_str
            )

        # Create upgrade directory if it does not exists
        path = os.path.join(os.path.dirname(m.__file__), "upgrades")
        if not os.path.exists(path) and create:
            os.makedirs(path)

        # Create init file if it does not exists
        init = os.path.join(path, "__init__.py")
        if not os.path.exists(init) and create:
            open(init, 'a').close()

        repository = m.__name__.split(".")[-1]

        return (path, repository)
    except ImportError:
        raise RuntimeError("Could not find module '%s'." % import_str)
    except SyntaxError:
        raise RuntimeError("Module '%s' has syntax errors." % import_str)
Ejemplo n.º 29
0
    def from_object(self, obj):
        """Updates the values from the given object.  An object can be of one
        of the following two types:

        -   a string: in this case the object with that name will be imported
        -   an actual object reference: that object is used directly

        Objects are usually either modules or classes.

        Just the uppercase variables in that object are stored in the config.
        Example usage::

            app.config.from_object('yourapplication.default_config')
            from yourapplication import default_config
            app.config.from_object(default_config)

        You should not use this function to load the actual configuration but
        rather configuration defaults.  The actual config should be loaded
        with :meth:`from_pyfile` and ideally from a location not within the
        package because the package might be installed system wide.

        :param obj: an import name or object
        """
        if isinstance(obj, basestring):
            obj = import_string(obj)
        for key in dir(obj):
            if key.isupper():
                self[key] = getattr(obj, key)
Ejemplo n.º 30
0
 def _import_model_if_not(self, model_name):
     if isinstance(self.models_dict[model_name], basestring):
         self.models_dict[model_name] = import_string(
             self.models_dict[model_name])
     if self.model_handlers[model_name] is None:
         self.model_handlers[model_name] = ModelHandler(
             model_name, self.models_dict[model_name])
Ejemplo n.º 31
0
def auto_discovery():
    for mod in find_modules("apps", recursive=True):
        if str(mod).endswith("tasks"):
            import_string(mod)
        elif str(mod).endswith("views"):
            import_string(mod)
Ejemplo n.º 32
0
def register_blueprints(app):
    for bp in bps:
        app.register_blueprint(import_string(bp))
Ejemplo n.º 33
0
def create_app(import_name,
               app_path,
               enabled_plugins,
               after_app_created=None,
               get_user_by_id=None,
               env=None):
    app_dot_path = app_path.replace('/', '.')
    # app and openapi
    app = None
    openapi_app = None
    if enabled_plugins.get('openapi'):
        import connexion
        openapi_app = connexion.FlaskApp(
            import_name, specification_dir=f'{app_path.strip("/")}/openapi/')
        app = openapi_app.app
        app.openapi_app = openapi_app
    else:
        app = Flask(import_name)
    app.app_path = app_path
    app.app_dot_path = app_dot_path
    app.enabled_plugins = enabled_plugins
    if after_app_created and not after_app_created():
        return app
    # config
    config = get_config(app_dot_path, env)
    app.config.from_object(config)
    app.secret_key = app.config['SECRET_KEY']
    app.static_url_path = '/static'
    # custom json encoder
    from .plugins.improved_json_encoder import ImprovedJsonEncoder
    app.json_encoder = ImprovedJsonEncoder
    # proxy_fix
    if enabled_plugins.get('proxy_fix'):
        from werkzeug.middleware.proxy_fix import ProxyFix
        '''
        Needed when app behind proxy, such as nginx or vue proxy server.
        If not fixed, url_for and session will not work properly.
        '''
        app.wsgi_app = ProxyFix(app.wsgi_app)
    # data validation
    DataValidator = import_string(f'{app_dot_path}.validator:DataValidator',
                                  silent=True)
    app.DataValidator = DataValidator or BaseDataValidator
    # cassandra
    if enabled_plugins.get('cassandra'):
        from cassandra.cqlengine import connection
        connection.setup([app.config['DB_HOST']],
                         app.config['DB_KEYSPACE'],
                         lazy_connect=True)
        from .plugins import cassandra_cqlengine, cassandra_cqlengine_elastic
    # mysql
    if enabled_plugins.get('mysql'):
        from flask_sqlalchemy import SQLAlchemy
        global _db
        # mysql://username:password@server:port/db?charset=utf8
        user = app.config['DB_USER']
        password = app.config['DB_PASS']
        server = app.config['DB_HOST']
        db_name = app.config['DB_NAME']
        charset = app.config.get('DB_CHARSET', 'utf8')
        port = app.config.get('DB_PORT', 3306)
        app.config[
            'SQLALCHEMY_DATABASE_URI'] = f'mysql+pymysql://{user}:{password}@{server}:{port}/{db_name}?charset={charset}'
        _db = db = SQLAlchemy(app)
    #
    with app.app_context():
        # cache
        # Check Configuring Flask-Cache section for more details
        if enabled_plugins.get('cache'):
            from flask_caching import Cache
            global _cache
            _cache = cache = Cache(config={'CACHE_TYPE': 'simple'})
            #
            oldSet = cache.set

            def custom_cache_set(key, value, timeout=None):
                '''
                timeout, unit minute
                '''
                if timeout != None:
                    timeout *= 60
                return oldSet(key, value, timeout)

            cache.set = custom_cache_set
            cache.init_app(app)
        # schedule_task
        if enabled_plugins.get('schedule_task'):
            from flask_apscheduler import APScheduler
            scheduler = APScheduler()
            scheduler.init_app(app)
            scheduler.start()
            app.scheduler = scheduler
            import_string(f'{app_dot_path}.schedule_tasks', silent=True)
        # flask_login
        if enabled_plugins.get('flask_login'):
            from flask_login import LoginManager, user_loaded_from_request
            from flask.sessions import SecureCookieSessionInterface
            User = import_string(f'{app_dot_path}.models:User')

            def get_user_by_id2(id):
                if enabled_plugins.get('cassandra'):
                    return User.objects(id=id).first()
                elif get_user_by_id:
                    return get_user_by_id(id)
                else:
                    raise Exception(
                        "Can't get user by id. The argument get_user_by_id is required."
                    )

            # session is also inited
            login_manager = LoginManager()
            login_manager.init_app(app)
            app.login_manager = login_manager
            if app.config.get('FLASK_LOGIN_DISABLE_COOKIE_LOGIN'):
                # with token
                @login_manager.request_loader
                def load_user_from_request(request):
                    from .plugins.jwt import decode_token
                    token = request.headers.get('Authorization')
                    if token:
                        prefix = 'Bearer '
                        if token.startswith(prefix):
                            token = token[len(prefix):]
                        r = decode_token(token)
                        if r['success']:
                            user_id = r['data']
                            return get_user_by_id2(user_id)
                    return None

                # disable cookie
                class CustomSessionInterface(SecureCookieSessionInterface):
                    """Prevent creating session from API requests."""
                    def save_session(self, *args, **kwargs):
                        if g.get('login_via_header'):
                            return
                        return super(CustomSessionInterface,
                                     self).save_session(*args, **kwargs)

                app.session_interface = CustomSessionInterface()
                #
                @user_loaded_from_request.connect
                def user_loaded_from_request_func(self, user=None):
                    g.login_via_header = True
            else:
                # with cookie
                @login_manager.user_loader
                def load_user(user_id):
                    return get_user_by_id2(user_id)

        # route
        if enabled_plugins.get('route'):
            route = import_string(f'{app_dot_path}.net', silent=True)
        # template global variables
        @app.context_processor
        def inject_global_variables_to_templates():
            return dict(setting=setting)

    return app
Ejemplo n.º 34
0
 def view(self):
     actual_view = import_string(self.import_name)
     if self.view_name:
         actual_view = actual_view.as_view(self.view_name)
     return actual_view
Ejemplo n.º 35
0
        try:
            run_simple(ip, port, app, use_debugger=use_debugger,
                       use_reloader=use_reloader, threaded=threaded)
            break
        except (OSError, socket.error):
            port += 1


if __name__ == '__main__':
    sys.path.insert(0, '.')
    if len(sys.argv) > 1:
        module_name = sys.argv[1]
        module_name = module_name.split('.py')[0]
        if ':' not in module_name:
            module_name += ':app'
        app = import_string(module_name)

    html_dirs = os.getenv("PICO_HTML_DIR") or {'/': 'static'}
    if html_dirs:
        html_dirs = {"/{}".format(os.path.basename(p)): p.replace("\\", "/")
                     for p in html_dirs.split(os.pathsep)}

        for d, p in html_dirs.items():
            assert os.path.isdir(
                p), "Not existing directory at path: {}".format(p)

    log.info("> html_dirs: {}".format(html_dirs))
    ip = os.getenv("PICO_IP", '127.0.0.1')

    if ip and ip.startswith('http'):
        ip = ip.replace("http://", "")
Ejemplo n.º 36
0
 def mod(self):
     """Load the module"""
     return import_string(self.path)
Ejemplo n.º 37
0
    def to_operation_dict(self) -> OperationSpecType:
        """Generate the openapi spec part of this endpoint.

        The result needs to be added to the `apispec` instance manually.
        """
        assert self.func is not None, "This object must be used in a decorator environment."
        assert self.operation_id is not None, "This object must be used in a decorator environment."

        module_obj = import_string(self.func.__module__)
        module_name = module_obj.__name__

        headers: Dict[str, OpenAPIParameter] = {}
        if self.etag in ('output', 'both'):
            etag_header = to_openapi([ETAG_HEADER_PARAM], 'header')[0]
            del etag_header['in']
            headers[etag_header.pop('name')] = etag_header

        responses: ResponseType = {}

        # We don't(!) support any endpoint without an output schema.
        # Just define one!
        if self.response_schema is not None:
            responses['200'] = {
                'content': {
                    self.content_type: {
                        'schema': self.response_schema
                    },
                },
                'description': apispec.utils.dedent(self.response_schema.__doc__ or ''),
                'headers': headers,
            }

        if self.will_do_redirects:
            responses['302'] = {
                'description':
                    ('Either the resource has moved or has not yet completed. Please see this '
                     'resource for further information.')
            }

        # Actually, iff you don't want to give out anything, then we don't need a schema.
        if self.output_empty:
            responses['204'] = {
                'description': 'Operation done successfully. No further output.',
                'headers': headers,
            }

        tag_obj: OpenAPITag = {
            'name': module_name,
        }
        docstring_name = _docstring_name(module_obj.__doc__)
        if docstring_name:
            tag_obj['x-displayName'] = docstring_name
        docstring_desc = _docstring_description(module_obj.__doc__)
        if docstring_desc:
            tag_obj['description'] = docstring_desc
        _add_tag(tag_obj, tag_group=self.tag_group)

        operation_spec: OperationSpecType = {
            'operationId': self.operation_id,
            'tags': [module_name],
            'description': '',
            'responses': {
                'default': {
                    'description': 'Any unsuccessful or unexpected result.',
                    'content': {
                        'application/problem+json': {
                            'schema': self.error_schema,
                        }
                    }
                }
            },
        }

        header_params: List[RawParameter] = []
        query_params: Sequence[
            RawParameter] = self.query_params if self.query_params is not None else []
        path_params: Sequence[
            RawParameter] = self.path_params if self.path_params is not None else []

        if self.etag in ('input', 'both'):
            header_params.append(ETAG_IF_MATCH_HEADER)

        operation_spec['parameters'] = coalesce_schemas([
            ('header', header_params),
            ('query', query_params),
            ('path', path_params),
        ])

        operation_spec['responses'].update(responses)

        if self.request_schema is not None:
            operation_spec['requestBody'] = {
                'required': self.request_body_required,
                'content': {
                    'application/json': {
                        'schema': self.request_schema,
                    }
                }
            }

        operation_spec['x-codeSamples'] = code_samples(self)

        # If we don't have any parameters we remove the empty list, so the spec will not have it.
        if not operation_spec['parameters']:
            del operation_spec['parameters']

        docstring_name = _docstring_name(self.func.__doc__)
        if docstring_name:
            operation_spec['summary'] = docstring_name
        else:
            raise RuntimeError(f"Please put a docstring onto {self.operation_id}")
        docstring_desc = _docstring_description(self.func.__doc__)
        if docstring_desc:
            operation_spec['description'] = docstring_desc

        apispec.utils.deepupdate(operation_spec, self.options)

        return {self.method: operation_spec}  # type: ignore[misc]
Ejemplo n.º 38
0
    def _add_api_spec(func):
        module_obj = import_string(func.__module__)
        module_name = module_obj.__name__
        operation_id = func.__module__ + "." + func.__name__

        if not output_empty and response_schema is None:
            raise ValueError(
                "%s: 'response_schema' required when output is to be sent!" %
                operation_id)

        if output_empty and response_schema:
            raise ValueError(
                "%s: On empty output 'output_schema' may not be used." %
                operation_id)

        # We don't(!) support any endpoint without an output schema.
        # Just define one!
        if response_schema is not None:
            path_item = {
                '200': {
                    'content': {
                        content_type: {
                            'schema': response_schema
                        },
                    },
                    'description':
                    apispec.utils.dedent(response_schema.__doc__ or ''),
                }
            }

        # Actually, iff you don't want to give out anything, then we don't need a schema.
        if output_empty:
            path_item = {
                '204': {
                    'description':
                    'Operation done successfully. No further output.'
                }
            }

        tag_obj = {'name': module_name}
        tag_obj.update(
            _docstring_keys(module_obj.__doc__, 'x-displayName',
                            'description'))
        _add_tag(tag_obj, tag_group='Endpoints')

        operation_spec = {
            'operationId': operation_id,
            'tags': [module_name],
            'description': '',
            'responses': {
                'default': {
                    'description': 'Any unsuccessful or unexpected result.',
                    'content': {
                        'application/problem+json': {
                            'schema': error_schema,
                        }
                    }
                }
            },
            'parameters': [],
        }

        if param_names:
            operation_spec['parameters'].extend(parameters)

        if etag in ('input', 'both'):
            operation_spec['parameters'].append(ETAG_IF_MATCH_HEADER)

        if etag in ('output', 'both'):
            # We can't put this completely in a schema because 'headers' is a map. We therefore
            # have to duplicate it every time.

            # NOTE: Be aware that this block only works under the assumption that only one(!)
            # http_status defined `operation_spec`. If this assumption no longer holds this block
            # needs to be refactored.
            only_key = list(path_item.keys())[0]
            path_item[only_key].setdefault('headers', {})
            path_item[only_key]['headers'].update(ETAG_HEADER_PARAM)

        operation_spec['responses'].update(path_item)

        if request_schema is not None:
            tag = _tag_from_schema(request_schema)
            _add_tag(tag, tag_group='Request Schemas')

            operation_spec['requestBody'] = {
                'required': request_body_required,
                'content': {
                    'application/json': {
                        'schema': request_schema,
                    }
                }
            }
            operation_spec['x-code-samples'] = code_samples(
                path, method, request_schema)

        # If we don't have any parameters we remove the empty list, so the spec will not have it.
        if not operation_spec['parameters']:
            del operation_spec['parameters']

        operation_spec.update(
            _docstring_keys(func.__doc__, 'summary', 'description'))
        apispec.utils.deepupdate(operation_spec, options)

        add_operation(path, method, operation_spec)

        if response_schema is None and request_schema is None:
            return func

        return wrap_with_validation(func, request_schema, response_schema)
Ejemplo n.º 39
0
def next_action(activity_id='0', action_id=0):
    """Next action."""
    work_activity = WorkActivity()
    history = WorkActivityHistory()

    post_json = request.get_json()
    activity = dict(activity_id=activity_id,
                    action_id=action_id,
                    action_version=post_json.get('action_version'),
                    action_status=ActionStatusPolicy.ACTION_DONE,
                    commond=post_json.get('commond'))

    action = Action().get_action_detail(action_id)
    action_endpoint = action.action_endpoint

    if action_endpoint == 'begin_action':
        return jsonify(code=0, msg=_('success'))

    if action_endpoint == 'end_action':
        work_activity.end_activity(activity)
        return jsonify(code=0, msg=_('success'))

    if action_endpoint == 'item_login':
        register_hdl(activity_id)

    activity_detail = work_activity.get_activity_detail(activity_id)
    item_id = None
    recid = None
    record = None
    pid_without_ver = None
    if activity_detail and activity_detail.item_id:
        item_id = activity_detail.item_id
        current_pid = PersistentIdentifier.get_by_object(pid_type='recid',
                                                         object_type='rec',
                                                         object_uuid=item_id)
        recid = get_record_identifier(current_pid.pid_value)
        record = WekoDeposit.get_record(item_id)
        if record:
            pid_without_ver = get_record_without_version(current_pid)
            deposit = WekoDeposit(record, record.model)

    if post_json.get('temporary_save') == 1 \
            and action_endpoint != 'identifier_grant':
        if 'journal' in post_json:
            work_activity.create_or_update_action_journal(
                activity_id=activity_id,
                action_id=action_id,
                journal=post_json.get('journal'))
        else:
            work_activity.upt_activity_action_comment(
                activity_id=activity_id,
                action_id=action_id,
                comment=post_json.get('commond'))
        return jsonify(code=0, msg=_('success'))
    elif post_json.get('journal'):
        work_activity.create_or_update_action_journal(
            activity_id=activity_id,
            action_id=action_id,
            journal=post_json.get('journal'))

    if action_endpoint == 'approval' and item_id:
        item = ItemsMetadata.get_record(id_=item_id)
        pid_identifier = PersistentIdentifier.get_by_object(
            pid_type='depid', object_type='rec', object_uuid=item.id)
        record_class = import_string('weko_deposit.api:WekoRecord')
        resolver = Resolver(pid_type='recid',
                            object_type='rec',
                            getter=record_class.get_record)
        _pid, _approval_record = resolver.resolve(pid_identifier.pid_value)

        action_feedbackmail = work_activity.get_action_feedbackmail(
            activity_id=activity_id, action_id=ITEM_REGISTRATION_ACTION_ID)
        if action_feedbackmail:
            FeedbackMailList.update(
                item_id=item_id,
                feedback_maillist=action_feedbackmail.feedback_maillist)
            if not recid and pid_without_ver:
                FeedbackMailList.update(
                    item_id=pid_without_ver.object_uuid,
                    feedback_maillist=action_feedbackmail.feedback_maillist)

        if record:
            deposit.update_feedback_mail()
            deposit.update_jpcoar_identifier()
        # TODO: Make private as default.
        # UpdateItem.publish(pid, approval_record)

    if action_endpoint == 'item_link' and record:
        current_pid = PersistentIdentifier.get_by_object(pid_type='recid',
                                                         object_type='rec',
                                                         object_uuid=item_id)

        if not pid_without_ver:
            pid_without_ver = get_record_without_version(current_pid)

        item_link = ItemLink(pid_without_ver.pid_value)
        relation_data = post_json.get('link_data')
        if relation_data:
            errors = item_link.update(relation_data)
            if errors:
                return jsonify(code=-1, msg=_(errors))

    # save pidstore_identifier to ItemsMetadata
    identifier_select = post_json.get('identifier_grant')
    if 'identifier_grant' == action_endpoint and identifier_select:
        idf_grant_jalc_doi_manual = post_json.get(
            'identifier_grant_jalc_doi_suffix')
        idf_grant_jalc_cr_doi_manual = post_json.get(
            'identifier_grant_jalc_cr_doi_suffix')
        idf_grant_jalc_dc_doi_manual = post_json.get(
            'identifier_grant_jalc_dc_doi_suffix')
        idf_grant_ndl_jalc_doi_manual = post_json.get(
            'identifier_grant_ndl_jalc_doi_suffix')

        # If is action identifier_grant, then save to to database
        identifier_grant = {
            'action_identifier_select': identifier_select,
            'action_identifier_jalc_doi': idf_grant_jalc_doi_manual,
            'action_identifier_jalc_cr_doi': idf_grant_jalc_cr_doi_manual,
            'action_identifier_jalc_dc_doi': idf_grant_jalc_dc_doi_manual,
            'action_identifier_ndl_jalc_doi': idf_grant_ndl_jalc_doi_manual
        }

        work_activity.create_or_update_action_identifier(
            activity_id=activity_id,
            action_id=action_id,
            identifier=identifier_grant)

        error_list = item_metadata_validation(item_id, identifier_select)

        if post_json.get('temporary_save') == 1:
            return jsonify(code=0, msg=_('success'))

        if isinstance(error_list, str):
            return jsonify(code=-1, msg=_(error_list))

        sessionstore = RedisStore(
            redis.StrictRedis.from_url('redis://{host}:{port}/1'.format(
                host=os.getenv('INVENIO_REDIS_HOST', 'localhost'),
                port=os.getenv('INVENIO_REDIS_PORT', '6379'))))
        if error_list:
            sessionstore.put('updated_json_schema_{}'.format(activity_id),
                             json.dumps(error_list).encode('utf-8'),
                             ttl_secs=300)
            return previous_action(activity_id=activity_id,
                                   action_id=action_id,
                                   req=-1)
        else:
            if sessionstore.redis.exists(
                    'updated_json_schema_{}'.format(activity_id)):
                sessionstore.delete(
                    'updated_json_schema_{}'.format(activity_id))

        if identifier_select != IDENTIFIER_GRANT_SELECT_DICT['NotGrant'] \
                and item_id is not None:
            record_without_version = item_id
            if record and pid_without_ver and not recid:
                record_without_version = pid_without_ver.object_uuid
            saving_doi_pidstore(item_id, record_without_version, post_json,
                                int(identifier_select))

    rtn = history.create_activity_history(activity)
    if not rtn:
        return jsonify(code=-1, msg=_('error'))
    # next action
    work_activity.upt_activity_action_status(
        activity_id=activity_id,
        action_id=action_id,
        action_status=ActionStatusPolicy.ACTION_DONE)
    work_activity.upt_activity_action_comment(activity_id=activity_id,
                                              action_id=action_id,
                                              comment='')
    flow = Flow()
    next_flow_action = flow.get_next_flow_action(
        activity_detail.flow_define.flow_id, action_id)
    if next_flow_action and len(next_flow_action) > 0:
        next_action_endpoint = next_flow_action[0].action.action_endpoint
        if 'end_action' == next_action_endpoint:
            new_activity_id = None
            if record:
                deposit.publish()
                updated_item = UpdateItem()
                # publish record without version ID when registering newly
                if recid:
                    # new record attached version ID
                    ver_attaching_record = deposit.newversion(current_pid)
                    new_activity_id = ver_attaching_record.model.id
                    ver_attaching_deposit = WekoDeposit(
                        ver_attaching_record, ver_attaching_record.model)
                    ver_attaching_deposit.publish()
                    record_bucket_id = merge_buckets_by_records(
                        current_pid.object_uuid,
                        ver_attaching_record.model.id,
                        sub_bucket_delete=True)
                    if not record_bucket_id:
                        return jsonify(code=-1, msg=_('error'))
                    # Record without version: Make status Public as default
                    updated_item.publish(record)
                else:
                    # update to record without version ID when editing
                    new_activity_id = record.model.id
                    if pid_without_ver:
                        record_without_ver = WekoDeposit.get_record(
                            pid_without_ver.object_uuid)
                        deposit_without_ver = WekoDeposit(
                            record_without_ver, record_without_ver.model)
                        deposit_without_ver['path'] = deposit.get('path', [])
                        parent_record = deposit_without_ver.\
                            merge_data_to_record_without_version(current_pid)
                        deposit_without_ver.publish()

                        set_bucket_default_size(new_activity_id)
                        merge_buckets_by_records(new_activity_id,
                                                 pid_without_ver.object_uuid)
                        updated_item.publish(parent_record)
                delete_unregister_buckets(new_activity_id)
            activity.update(
                action_id=next_flow_action[0].action_id,
                action_version=next_flow_action[0].action_version,
                item_id=new_activity_id,
            )
            work_activity.end_activity(activity)
        else:
            next_action_id = next_flow_action[0].action_id
            work_activity.upt_activity_action(
                activity_id=activity_id,
                action_id=next_action_id,
                action_status=ActionStatusPolicy.ACTION_DOING)
    # delete session value
    if session.get('itemlogin_id'):
        del session['itemlogin_id']
        del session['itemlogin_activity']
        del session['itemlogin_item']
        del session['itemlogin_steps']
        del session['itemlogin_action_id']
        del session['itemlogin_cur_step']
        del session['itemlogin_record']
        del session['itemlogin_res_check']
        del session['itemlogin_pid']
        del session['itemlogin_community_id']
    return jsonify(code=0, msg=_('success'))
Ejemplo n.º 40
0
    def handle_collection(self, content):
        """
        :param content:
        :return:
        """
        for item in content['item']:
            try:
                # 注意这里是直接取postman数据,不改变数据类型,因此body是dict。
                if len(item['name']) < 64:
                    name = item['name']
                else:
                    name = item['name'][0:64]

                header = item['request']['header']
                method = item['request']['method'].lower()

                host = item['request']['url']['protocol'] + '://' + \
                       '.'.join(item['request']['url']['host'])
                if 'port' in item['request']['url']:
                    host += ':' + item['request']['url']['port']

                # path默认是首页请求,如果不是则进行拼接
                path = '/'
                if 'path' in item['request']['url']:
                    path += '/'.join(item['request']['url']['path'])

                if 'query' in item['request']['url']:
                    params = item['request']['url']['query']
                else:
                    params = []

                if 'body' in item['request']:
                    if item['request']['body'].get('mode') == 'formdata':
                        body = {
                            'mode': item['request']['body']['mode'],
                            'data': item['request']['body']['formdata']
                        }
                    elif item['request']['body'].get('mode') == 'urlencoded':
                        body = {
                            'mode': item['request']['body']['mode'],
                            'data': item['request']['body']['urlencoded']
                        }
                    elif item['request']['body'].get('mode') == 'file':
                        body = {
                            'mode': item['request']['body']['mode'],
                            'data': item['request']['body']['file']
                        }
                    else:
                        body = {
                            'mode': item['request']['body'].get('mode')
                            or 'raw',
                            'data': item['request']['body'].get('raw') or ''
                        }
                else:
                    body = {'mode': 'raw', 'data': ''}

                host = self.change_postman_variable_to_clover(host)
                path = self.change_postman_variable_to_clover(path)
                header = self.change_postman_variable_to_clover(header)
                params = self.change_postman_variable_to_clover(params)
                body = self.change_postman_variable_to_clover(body)

                interface = {
                    'team': self.team,
                    'project': self.project,
                    'name': name,
                    'method': method,
                    'host': host,
                    'path': path,
                    'header': header,
                    'params': params,
                    'body': body,
                    'verify': [],
                    'extract': [],
                }

                plugin = 'clover.interface.service:InterfaceService'
                service = import_string(plugin)()
                _, status, _, _ = service.create(interface)
                if status == 0:
                    self.result['success'] += 1
                else:
                    self.result['failed'] += 1
            except Exception:
                self.result['failed'] += 1
            self.result['total'] += 1
Ejemplo n.º 41
0
# limitations under the License.
"""Copy of Data Commons Python Client API Core without pandas dependency."""

import base64
import collections
import json
import logging
import os
import zlib
import urllib

import requests
from werkzeug.utils import import_string

if os.environ.get('FLASK_ENV') == 'test':
    cfg = import_string('configmodule.TestConfig')()
elif os.environ.get('FLASK_ENV') == 'webdriver':
    cfg = import_string('configmodule.WebdriverConfig')()
elif os.environ.get('FLASK_ENV') == 'production':
    cfg = import_string('configmodule.ProductionConfig')()
elif os.environ.get('FLASK_ENV') == 'staging':
    cfg = import_string('configmodule.StagingConfig')()
else:
    cfg = import_string('configmodule.DevelopmentConfig')()

API_ROOT = cfg.API_ROOT
API_PROJECT = cfg.API_PROJECT

DC_API_KEY = 'api-key'
# if (os.environ.get('FLASK_ENV') == 'test' or
#         os.environ.get('FLASK_ENV') == 'webdriver'):
Ejemplo n.º 42
0
class Resource(object):
    """The core class that represents a REST resource.

    :param action_map: the mapping of request methods to resource actions.
    """

    #: The name of the resource.
    name = None

    #: The parser classes used for parsing request data.
    parser_classes = tuple(
        import_string(parser_class) for parser_class in config.PARSER_CLASSES)

    #: The renderer classes used for rendering response data.
    renderer_classes = tuple(
        import_string(renderer_class)
        for renderer_class in config.RENDERER_CLASSES)

    #: The class used to select the proper parser or renderer
    negotiator_class = Negotiator

    #: The resource-level middleware classes
    middleware_classes = ()

    def __init__(self, action_map):
        self.action_map = action_map

    @locked_cached_classproperty(name='_middlewares')
    def middlewares(cls):
        """The instances of all middleware classes.

        The final order of middleware classes:
            The first is global middleware classes (in order) and
            then is resource-level middleware classes (in order).
        """
        global_middleware_classes = tuple(
            import_string(middleware_class_string)
            for middleware_class_string in config.MIDDLEWARE_CLASSES)
        middleware_classes = global_middleware_classes + cls.middleware_classes
        return tuple(middleware_class()
                     for middleware_class in middleware_classes)

    @property
    def logger(self):
        """A :class:`logging.Logger` object for this API."""
        from .logging import global_logger
        return global_logger

    def _get_head(self):
        """Get the head message for logging."""
        query_string = self.request.environ['QUERY_STRING']
        separator = '?' if query_string else ''
        head = '[%s %s%s%s]' % (self.request.method, self.request.path,
                                separator, query_string)
        return head

    def log_message(self, msg):
        """Logs a message with `DEBUG` level.

        :param msg: the message to be logged.
        """
        if self.request.method in config.LOGGER_METHODS:
            self.logger.debug('%s %s' % (self._get_head(), msg))

    def log_exception(self, exc):
        """Logs an exception with `ERROR` level.

        :param exc: the exception to be logged.
        """
        self.logger.exception('Exception on %s' % self._get_head())

    def get_parser_context(self, request, args, kwargs):
        """Return a dictionary that represents a parser context.

        :param request: the request object.
        :param args: the positional arguments captured from the URI.
        :param kwargs: the keyword arguments captured from the URI.
        """
        return {
            'resource': self,
            'request': request,
            'args': args,
            'kwargs': kwargs
        }

    def get_renderer_context(self, request, args, kwargs, response):
        """Return a dictionary that represents a renderer context.

        :param request: the request object.
        :param args: the positional arguments captured from the URI.
        :param kwargs: the keyword arguments captured from the URI.
        :param response: the response object.
        """
        return {
            'resource': self,
            'request': request,
            'args': args,
            'kwargs': kwargs,
            'response': response
        }

    def dispatch_request(self, request, *args, **kwargs):
        """Does the request dispatching. Matches the HTTP method and return
        the return value of the bound action.

        :param request: the request object.
        :param args: the positional arguments captured from the URI.
        :param kwargs: the keyword arguments captured from the URI.
        """
        negotiator = self.negotiator_class()
        self.format_suffix = kwargs.pop('format', None)

        parser_context = self.get_parser_context(request, args, kwargs)
        self.request = request

        try:
            request.parse(negotiator, self.parser_classes, parser_context)
            self.log_message('<Request> %s' % request.data)

            rv = self.perform_action(*args, **kwargs)
        except Exception as exc:
            rv = self.handle_exception(exc)

        response = self.make_response(rv)
        self.log_message('<Response> %s %s' % (response.status, response.data))

        renderer_context = self.get_renderer_context(request, args, kwargs,
                                                     response)
        return response.render(negotiator, self.renderer_classes,
                               self.format_suffix, renderer_context)

    def http_method_not_allowed(self, request, *args, **kwargs):
        """The default action handler if the corresponding action for
        `request.method` is not implemented.

        See :meth:`dispatch_request` for the meanings of the parameters.
        """
        raise exceptions.MethodNotAllowed()

    def find_action(self, request):
        """Find the appropriate action according to the request method.

        :param request: the request object.
        """
        try:
            action_name = self.action_map[request.method]
        except KeyError as exc:
            exc.args = ('Config `ACTION_MAP` has no mapping for %r' %
                        request.method, )
            raise

        action = getattr(self, action_name, self.http_method_not_allowed)
        return action

    def perform_action(self, *args, **kwargs):
        """Perform the appropriate action. Also apply all possible `process_*`
        methods of middleware instances in `self.middlewares`.

        During request phase:

            :meth:`process_request` methods are called on each request,
            before RESTArt calls the `action`, in order.

            It should return :attr:`None` or any other value that
            :attr:`~restart.resource.Resource.make_response` can recognize.
            If it returns :attr:`None`, RESTArt will continue processing
            the request, executing any other :meth:`process_request` and,
            then, the `action`. If it returns any other value (e.g.
            a :class:`~restart.response.Response` object), RESTArt won't
            bother calling any other middleware or the `action`.

        During response phase:

            :meth:`process_response` methods are called on all responses
            before they'are returned to the client, in reverse order.

            It must return a value that can be converted to a
            :class:`~restart.response.Response` object by
            :attr:`~restart.resource.Resource.make_response`. It could alter
            and return the given `response`, or it could create and return
            a brand-new value.

            Unlike :meth:`process_request` methods, the
            :meth:`process_response` method is always called, even if the
            :meth:`process_request` of the same middleware were skipped
            (because an earlier middleware method returned a
            :class:`~restart.response.Response`).

        :param args: a list of positional arguments that will be passed
                     to the action.
        :param kwargs: a dictionary of keyword arguments that will be passed
                       to the action.
        """
        rv = None

        # Call possible `process_request` methods of middlewares
        for middleware in self.middlewares:
            if hasattr(middleware, 'process_request'):
                rv = middleware.process_request(self.request)
                if rv is not None:
                    break

        # Call the `action`
        if rv is None:
            action = self.find_action(self.request)
            rv = action(self.request, *args, **kwargs)

        # Call all `process_response` methods of middlewares
        for middleware in reversed(self.middlewares):
            if hasattr(middleware, 'process_response'):
                # Ensure that the second parameter passed to the
                # `process_response` method is a `Response` object
                response = self.make_response(rv)
                rv = middleware.process_response(self.request, response)

        return rv

    def handle_exception(self, exc):
        """Handle any exception that occurs, by returning an appropriate
        response, or re-raising the error.

        :param exc: the exception to be handled.
        """
        if isinstance(exc, exceptions.HTTPException):
            # Always render `HTTPException` messages into JSON
            from .renderers import JSONRenderer
            self.renderer_classes = (JSONRenderer, )

            headers = dict(exc.get_headers(self.request.environ))
            rv = ({'message': exc.description}, exc.code, headers)
            return rv
        else:
            self.log_exception(exc)
            raise

    def make_response(self, rv):
        """Converts the return value to a real response object that is
        an instance of :class:`~restart.response.Response`.

        The following types are allowed for `rv`:

        ======================  ============================================
        :class:`Response`       the object is returned unchanged
        :class:`str`            the string becomes the response body
        :class:`unicode`        the unicode string becomes the response body
        :class:`tuple`          A tuple in the form ``(data, status)``
                                or ``(data, status, headers)`` where
                                `data` is the response body, `status` is
                                an integer and `headers` is a dictionary
                                with header values.
        ======================  ============================================
        """
        status = 200
        headers = None

        if isinstance(rv, tuple):
            rv_len = len(rv)
            if rv_len == 2:
                rv, status = rv
            elif rv_len == 3:
                rv, status, headers = rv
            else:
                raise ValueError('Resource action return a wrong response')

        if rv is None:
            raise ValueError('Resource action did not return a response')
        elif not isinstance(rv, Response):
            rv = Response(rv, status=status, headers=headers)

        return rv
Ejemplo n.º 43
0
 def load(self):
     """Mock load entry point."""
     if self.name == 'importfail':
         raise ImportError()
     else:
         return import_string(self.name)
Ejemplo n.º 44
0
    def server(self):
        """
        All in one endpoints. This property is created automaticly
        if you have implemented all the getters and setters.

        However, if you are not satisfied with the getter and setter,
        you can create a validator with :class:`OAuth2RequestValidator`::

            class MyValidator(OAuth2RequestValidator):
                def validate_client_id(self, client_id):
                    # do something
                    return True

        And assign the validator for the provider::

            oauth._validator = MyValidator()
        """
        expires_in = self.app.config.get('OAUTH2_PROVIDER_TOKEN_EXPIRES_IN')
        token_generator = self.app.config.get(
            'OAUTH2_PROVIDER_TOKEN_GENERATOR', None)
        if token_generator and not callable(token_generator):
            token_generator = import_string(token_generator)

        refresh_token_generator = self.app.config.get(
            'OAUTH2_PROVIDER_REFRESH_TOKEN_GENERATOR', None)
        if refresh_token_generator and not callable(refresh_token_generator):
            refresh_token_generator = import_string(refresh_token_generator)

        if hasattr(self, '_validator'):
            return Server(
                self._validator,
                token_expires_in=expires_in,
                token_generator=token_generator,
                refresh_token_generator=refresh_token_generator,
            )

        if hasattr(self, '_clientgetter') and \
           hasattr(self, '_tokengetter') and \
           hasattr(self, '_tokensetter') and \
           hasattr(self, '_grantgetter') and \
           hasattr(self, '_grantsetter'):

            usergetter = None
            if hasattr(self, '_usergetter'):
                usergetter = self._usergetter

            validator = OAuth2RequestValidator(
                clientgetter=self._clientgetter,
                tokengetter=self._tokengetter,
                grantgetter=self._grantgetter,
                usergetter=usergetter,
                tokensetter=self._tokensetter,
                grantsetter=self._grantsetter,
            )
            self._validator = validator
            return Server(
                validator,
                token_expires_in=expires_in,
                token_generator=token_generator,
                refresh_token_generator=refresh_token_generator,
            )
        raise RuntimeError('application not bound to required getters')
Ejemplo n.º 45
0
except Exception as e:
    raise 'backend_dir listdir failed!'

# 目录为空,或者不是list
if not backend_dir or not isinstance(backend_dir, list):
    raise 'backend_dir is empty!'

from werkzeug.utils import import_string
# 遍历注册 Blueprint
for blue_dir in backend_dir:
    # 不是目录,忽略
    if not os.path.isdir(os.path.join(PATH_BACKEND, blue_dir)):
        continue

    # 缓存目录,忽略
    if blue_dir.startswith('_'):
        continue

    # 导入并注册
    class_blueprint = import_string('%s.%s.%s_blueprint' %
                                    ('backend', blue_dir, blue_dir))
    backend_server.register_blueprint(class_blueprint,
                                      url_prefix='/%s' % blue_dir)

if __name__ == '__main__':
    '''
    启动服务器
    python backend_server.py
    '''
    backend_server.run(host='127.0.0.1', port=8577, threaded=True, debug=True)
Ejemplo n.º 46
0
def iter_suites():
    """Yields all testsuites."""
    for module in find_modules(__name__):
        mod = import_string(module)
        if hasattr(mod, 'suite'):
            yield mod.suite()
Ejemplo n.º 47
0
def register_blueprints(app):
    for name in find_modules("src.handler"):
        mod = import_string(name)
        if hasattr(mod, "blueprint"):
            app.register_blueprint(mod.blueprint)
    return None
Ejemplo n.º 48
0
    def to_operation_dict(self) -> OperationSpecType:
        """Generate the openapi spec part of this endpoint.

        The result needs to be added to the `apispec` instance manually.
        """
        assert self.func is not None, "This object must be used in a decorator environment."
        assert self.operation_id is not None, "This object must be used in a decorator environment."

        module_obj = import_string(self.func.__module__)

        response_headers: Dict[str, OpenAPIParameter] = {}
        content_type_header = to_openapi([CONTENT_TYPE], "header")[0]
        del content_type_header["in"]
        response_headers[content_type_header.pop("name")] = content_type_header

        if self.etag in ("output", "both"):
            etag_header = to_openapi([ETAG_HEADER_PARAM], "header")[0]
            del etag_header["in"]
            response_headers[etag_header.pop("name")] = etag_header

        responses: ResponseType = {}

        if self.tag_group == "Setup":
            responses["403"] = self._path_item(
                403, "Configuration via WATO is disabled")

        if 404 in self._expected_status_codes:
            responses["404"] = self._path_item(
                404, "The requested object has not been found.")

        if 422 in self._expected_status_codes:
            responses["422"] = self._path_item(
                422, "The request could not be processed.")

        if 405 in self._expected_status_codes:
            responses["405"] = _path_item(
                405, "Method not allowed: This request is only allowed "
                "with other HTTP methods")

        if 409 in self._expected_status_codes:
            responses["409"] = self._path_item(
                409,
                "The request is in conflict with the stored resource.",
            )

        if 415 in self._expected_status_codes:
            responses["415"] = self._path_item(
                415, "The submitted content-type is not supported.")

        if 302 in self._expected_status_codes:
            responses["302"] = self._path_item(
                302,
                "Either the resource has moved or has not yet completed. Please see this "
                "resource for further information.",
            )

        if 400 in self._expected_status_codes:
            responses["400"] = self._path_item(
                400, "Parameter or validation failure.")

        # We don't(!) support any endpoint without an output schema.
        # Just define one!
        if 200 in self._expected_status_codes:
            if self.response_schema:
                content: ContentObject
                content = {self.content_type: {"schema": self.response_schema}}
            elif self.content_type == "application/octet-stream" or self.content_type.startswith(
                    "image/"):
                content = {
                    self.content_type: {
                        "schema": {
                            "type": "string",
                            "format": "binary",
                        }
                    }
                }
            else:
                raise ValueError(
                    f"Unknown content-type: {self.content_type} Please add condition."
                )
            responses["200"] = self._path_item(
                200,
                "The operation was done successfully.",
                content=content,
                headers=response_headers,
            )

        if 204 in self._expected_status_codes:
            responses["204"] = self._path_item(
                204, "Operation done successfully. No further output.")

        if 412 in self._expected_status_codes:
            responses["412"] = self._path_item(
                412,
                "The value of the If-Match header doesn't match the object's ETag.",
            )

        if 428 in self._expected_status_codes:
            responses["428"] = self._path_item(
                428, "The required If-Match header is missing.")

        docstring_name = _docstring_name(module_obj.__doc__)
        tag_obj: OpenAPITag = {
            "name": docstring_name,
            "x-displayName": docstring_name,
        }
        docstring_desc = _docstring_description(module_obj.__doc__)
        if docstring_desc:
            tag_obj["description"] = docstring_desc
        _add_tag(tag_obj, tag_group=self.tag_group)

        operation_spec: OperationSpecType = {
            "operationId": self.operation_id,
            "tags": [docstring_name],
            "description": "",
        }

        header_params: List[RawParameter] = []
        query_params: Sequence[RawParameter] = (
            self.query_params if self.query_params is not None else [])
        path_params: Sequence[RawParameter] = (
            self.path_params if self.path_params is not None else [])

        if config.rest_api_etag_locking and self.etag in ("input", "both"):
            header_params.append(ETAG_IF_MATCH_HEADER)

        if self.request_schema:
            header_params.append(CONTENT_TYPE)

        # While we define the parameters separately to be able to use them for validation, the
        # OpenAPI spec expects them to be listed in on place, so here we bunch them together.
        operation_spec["parameters"] = coalesce_schemas([
            ("header", header_params),
            ("query", query_params),
            ("path", path_params),
        ])

        operation_spec["responses"] = responses

        if self.request_schema is not None:
            operation_spec["requestBody"] = {
                "required": True,
                "content": {
                    "application/json": {
                        "schema": self.request_schema,
                    }
                },
            }

        operation_spec["x-codeSamples"] = code_samples(
            self,
            header_params=header_params,
            path_params=path_params,
            query_params=query_params,
        )

        # If we don't have any parameters we remove the empty list, so the spec will not have it.
        if not operation_spec["parameters"]:
            del operation_spec["parameters"]

        docstring_name = _docstring_name(self.func.__doc__)
        if docstring_name:
            operation_spec["summary"] = docstring_name
        else:
            raise RuntimeError(
                f"Please put a docstring onto {self.operation_id}")
        docstring_desc = _docstring_description(self.func.__doc__)
        if docstring_desc:
            operation_spec["description"] = docstring_desc

        apispec.utils.deepupdate(operation_spec, self.options)

        return {self.method: operation_spec}  # type: ignore[misc]
Ejemplo n.º 49
0
 def view(self):
     return import_string(self.import_name)
Ejemplo n.º 50
0
 def cache(self):
     """Return a cache instance."""
     cache = self._cache or self.app.config.get('ACCESS_CACHE')
     return import_string(cache) if isinstance(cache, six.string_types) \
         else cache
Ejemplo n.º 51
0
def create_app(config_name):
    app = Flask(config_name)
    app.config.from_object(config[config_name])

    # 全局响应头
    @app.after_request
    def after_request(response):
        if "Access-Control-Allow-Origin" not in response.headers.keys():
            response.headers['Access-Control-Allow-Origin'] = '*'
        if request.method == 'OPTIONS':
            response.headers[
                'Access-Control-Allow-Methods'] = 'DELETE, GET, POST, PUT'
            headers = request.headers.get('Access-Control-Request-Headers')
            if headers:
                response.headers['Access-Control-Allow-Headers'] = headers
        return response

    # 自定义错误日志
    handler = logging.FileHandler('app.log', encoding='UTF-8')
    logging_format = logging.Formatter(
        '%(asctime)s - %(levelname)s - %(filename)s - %(funcName)s - %(lineno)s - %(message)s'
    )
    handler.setFormatter(logging_format)
    app.logger.addHandler(handler)

    def init_login():
        login_manager = login.LoginManager()
        login_manager.setup_app(app)

        # Create user loader function
        @login_manager.user_loader
        def load_user(user_id):
            return AdminUser.objects(id=user_id).first()

    @app.errorhandler(404)
    def page_not_found(e):
        return jsonify(msg='404 page not found')

    # 注册所有蓝图
    for bp_name in blueprints:
        bp = import_string(bp_name)
        app.register_blueprint(bp)

    config[config_name].init_app(app)
    babel = Babel(app)
    db.init_app(app)
    docs.init_app(app)
    admin.init_app(app)
    init_login()
    limiter.init_app(app)
    celery.init_app(app)
    redis.init_app(app)
    celery.conf.update(app.config)

    db.register_connection(db='ultrabear_homework',
                           alias="home",
                           port=PORT,
                           username=NAME,
                           password=PWD)
    # 跨域
    CORS(app, supports_credentials=True)
    return app
Ejemplo n.º 52
0
def lazy_import(name):
    """
    Lazy import of name using `Werzeug.local.import_string`.
    """
    return LocalProxy(lambda: import_string(name))
Ejemplo n.º 53
0
# REANA is free software; you can redistribute it and/or modify it
# under the terms of the MIT License; see LICENSE file for more details.
"""Flask application configuration."""

import os

from reana_commons.config import REANA_COMPONENT_PREFIX

from werkzeug.utils import import_string

SHARED_VOLUME_PATH_ROOT = os.getenv("SHARED_VOLUME_PATH_ROOT", "/var/reana")
"""Root path of the shared volume ."""

COMPUTE_BACKENDS = {
    "kubernetes":
    lambda: import_string(
        "reana_job_controller.kubernetes_job_manager.KubernetesJobManager"),
    "htcondorcern":
    lambda: import_string(
        "reana_job_controller.htcondorcern_job_manager.HTCondorJobManagerCERN"
    ),
    "slurmcern":
    lambda: import_string(
        "reana_job_controller.slurmcern_job_manager.SlurmJobManagerCERN"),
}
"""Supported job compute backends and corresponding management class."""

JOB_MONITORS = {
    "kubernetes":
    lambda: import_string(
        "reana_job_controller.job_monitor.JobMonitorKubernetes"),
    "htcondorcern":
Ejemplo n.º 54
0
def import_bp_string(module_name):
    import_name = '%s.bps.%s:bp' % (__package__, module_name)
    return import_string(import_name)
Ejemplo n.º 55
0
import os
from werkzeug.utils import import_string
from service.config import set_config

set_config(
    import_string(os.environ.get('APP_CONFIG', 'service.config.TestConfig')))
Ejemplo n.º 56
0
from flask import Flask
from flask_login import LoginManager
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from flask_bootstrap import Bootstrap
from flask_uploads import UploadSet, configure_uploads, IMAGES
from werkzeug.utils import import_string

app = Flask(__name__)
if app.config["ENV"] == "production":
    cfg = import_string('config.config.ProductionConfig')()
    app.config.from_object(cfg)
else:
    cfg = import_string('config.config.DevelopmentConfig')()
    app.config.from_object(cfg)

print(f' Flask ENV is set to: {app.config["ENV"]}')

photos = UploadSet('photos', IMAGES)

configure_uploads(app, photos)

db = SQLAlchemy(app)
migrate = Migrate(app, db)

manager = Manager(app)
manager.add_command('db', MigrateCommand)

login_manager = LoginManager(app)
login_manager.login_view = 'login'
Ejemplo n.º 57
0
 def translation_path_from_config(self):
     try:
         return import_string(
             current_app.config.get("OY_TRANSLATIONS_PATH", "")).__path__[0]
     except ValueError:
         return
def configure_admin(app, admin):  # noqa

    custom_index = app.config.get('ADMIN_INDEX_VIEW')
    if custom_index:
        admin.index_view = import_string(custom_index)()
        if isinstance(admin._views[0], BaseIndexView):
            del admin._views[0]
        admin._views.insert(0, admin.index_view)

    admin_config = app.config.get('ADMIN', {
        'name': 'Quokka Admin',
        'url': '/admin'
    })

    for k, v in list(admin_config.items()):
        setattr(admin, k, v)

    for entry in app.config.get('FILE_ADMIN', []):
        try:
            admin.add_view(
                FileAdmin(
                    entry['path'],
                    entry['url'],
                    name=_l(entry['name']),
                    category=_l(entry['category']),
                    endpoint=entry['endpoint'],
                    roles_accepted=entry.get('roles_accepted'),
                    editable_extensions=entry.get('editable_extensions')))
        except Exception as e:
            app.logger.info(e)

    # register all themes in file manager
    for k, theme in app.theme_manager.themes.items():
        try:

            if k == app.config.get('DEFAULT_THEME'):
                suffix = "(Site theme)"
            elif k == app.config.get('ADMIN_THEME'):
                suffix = "(Admin theme)"
            else:
                suffix = "Theme"

            admin.add_view(
                FileAdmin(theme.static_path,
                          "/_themes/{0}/".format(theme.identifier),
                          name="{0}: {1} static files".format(
                              suffix, theme.identifier),
                          category=_l("Files"),
                          endpoint="{0}_static_files".format(theme.identifier),
                          roles_accepted=('admin', "editor"),
                          editable_extensions=app.config.get(
                              'DEFAULT_EDITABLE_EXTENSIONS')))
            admin.add_view(
                FileAdmin(
                    theme.templates_path,
                    "/theme_template_files/{0}/".format(theme.identifier),
                    name="{0}: {1} template files".format(
                        suffix, theme.identifier),
                    category=_l("Files"),
                    endpoint="{0}_template_files".format(theme.identifier),
                    roles_accepted=('admin', "editor"),
                    editable_extensions=app.config.get(
                        'DEFAULT_EDITABLE_EXTENSIONS')))
        except Exception as e:
            app.logger.warning('Error registering %s folder to file admin %s' %
                               (theme.identifier, e))

    # adding views
    admin.add_view(InspectorView(category=_l("Settings"),
                                 name=_l("Inspector")))

    # adding extra views
    extra_views = app.config.get('ADMIN_EXTRA_VIEWS', [])
    for view in extra_views:
        admin.add_view(
            import_string(view['module'])(category=_l(view.get('category')),
                                          name=_l(view.get('name'))))

    # adding model views
    admin.register(Link, LinkAdmin, category=_l("Content"), name=_l("Link"))
    admin.register(Config,
                   ConfigAdmin,
                   category=_l("Settings"),
                   name=_l("Config"))
    admin.register(SubContentPurpose,
                   SubContentPurposeAdmin,
                   category=_l("Settings"),
                   name=_l("Sub content purposes"))
    admin.register(ChannelType,
                   ChannelTypeAdmin,
                   category=_l("Settings"),
                   name=_l("Channel type"))
    admin.register(ContentTemplateType,
                   ContentTemplateTypeAdmin,
                   category=_l("Settings"),
                   name=_l("Template type"))
    admin.register(Channel,
                   ChannelAdmin,
                   category=_l("Content"),
                   name=_l("Channel"))

    # avoid registering twice
    if admin.app is None:
        admin.init_app(app)

    return admin
Ejemplo n.º 59
0
def display_activity(activity_id=0):
    """Display activity."""
    activity = WorkActivity()
    activity_detail = activity.get_activity_detail(activity_id)
    item = None
    if activity_detail and activity_detail.item_id:
        try:
            item = ItemsMetadata.get_record(id_=activity_detail.item_id)
        except NoResultFound as ex:
            current_app.logger.exception(str(ex))
            item = None

    steps = activity.get_activity_steps(activity_id)
    history = WorkActivityHistory()
    histories = history.get_activity_history_list(activity_id)
    workflow = WorkFlow()
    workflow_detail = workflow.get_workflow_by_id(activity_detail.workflow_id)

    if activity_detail.activity_status == \
        ActivityStatusPolicy.ACTIVITY_FINALLY \
        or activity_detail.activity_status == \
            ActivityStatusPolicy.ACTIVITY_CANCEL:
        activity_detail.activity_status_str = _('End')
    else:
        activity_detail.activity_status_str = \
            request.args.get('status', 'ToDo')
    cur_action = activity_detail.action
    action_endpoint = cur_action.action_endpoint
    action_id = cur_action.id
    temporary_comment = activity.get_activity_action_comment(
        activity_id=activity_id, action_id=action_id)

    # display_activity of Identifier grant
    identifier_setting = None
    if action_endpoint == 'identifier_grant' and item:
        community_id = request.args.get('community', None)
        if not community_id:
            community_id = 'Root Index'
        identifier_setting = get_identifier_setting(community_id)

        # valid date pidstore_identifier data
        if identifier_setting:
            text_empty = '<Empty>'
            if not identifier_setting.jalc_doi:
                identifier_setting.jalc_doi = text_empty
            if not identifier_setting.jalc_crossref_doi:
                identifier_setting.jalc_crossref_doi = text_empty
            if not identifier_setting.jalc_datacite_doi:
                identifier_setting.jalc_datacite_doi = text_empty
            if not identifier_setting.ndl_jalc_doi:
                identifier_setting.ndl_jalc_doi = text_empty

    temporary_identifier_select = 0
    temporary_identifier_inputs = []
    last_identifier_setting = activity.get_action_identifier_grant(
        activity_id=activity_id, action_id=action_id)
    if last_identifier_setting:
        temporary_identifier_select = last_identifier_setting.get(
            'action_identifier_select')
        temporary_identifier_inputs.append(
            last_identifier_setting.get('action_identifier_jalc_doi'))
        temporary_identifier_inputs.append(
            last_identifier_setting.get('action_identifier_jalc_cr_doi'))
        temporary_identifier_inputs.append(
            last_identifier_setting.get('action_identifier_jalc_dc_doi'))
        temporary_identifier_inputs.append(
            last_identifier_setting.get('action_identifier_ndl_jalc_doi'))

    temporary_journal = activity.get_action_journal(activity_id=activity_id,
                                                    action_id=action_id)
    if temporary_journal:
        temporary_journal = temporary_journal.action_journal

    cur_step = action_endpoint
    step_item_login_url = None
    approval_record = []
    pid = None
    record = {}
    need_file = False
    need_billing_file = False
    json_schema = ''
    schema_form = ''
    item_save_uri = ''
    files = []
    endpoints = {}
    links = None
    need_thumbnail = False
    files_thumbnail = []
    allow_multi_thumbnail = False
    show_autofill_metadata = True
    is_hidden_pubdate_value = False
    item_type_name = get_item_type_name(workflow_detail.itemtype_id)

    if 'item_login' == action_endpoint or 'file_upload' == action_endpoint:
        activity_session = dict(activity_id=activity_id,
                                action_id=activity_detail.action_id,
                                action_version=cur_action.action_version,
                                action_status=ActionStatusPolicy.ACTION_DOING,
                                commond='')
        show_autofill_metadata = is_show_autofill_metadata(item_type_name)
        is_hidden_pubdate_value = is_hidden_pubdate(item_type_name)
        session['activity_info'] = activity_session
        # get item edit page info.
        step_item_login_url, need_file, need_billing_file, \
            record, json_schema, schema_form,\
            item_save_uri, files, endpoints, need_thumbnail, files_thumbnail, \
            allow_multi_thumbnail \
            = item_login(item_type_id=workflow_detail.itemtype_id)
        if item:
            # Remove the unused local variable
            # _pid_identifier = PersistentIdentifier.get_by_object(
            #     pid_type='depid', object_type='rec', object_uuid=item.id)
            record = item

        sessionstore = RedisStore(
            redis.StrictRedis.from_url('redis://{host}:{port}/1'.format(
                host=os.getenv('INVENIO_REDIS_HOST', 'localhost'),
                port=os.getenv('INVENIO_REDIS_PORT', '6379'))))
        if sessionstore.redis.exists(
            'updated_json_schema_{}'.format(activity_id)) \
            and sessionstore.get(
                'updated_json_schema_{}'.format(activity_id)):
            json_schema = (json_schema + "/{}").format(activity_id)

    # if 'approval' == action_endpoint:
    if item:
        # get record data for the first time access to editing item screen
        pid_identifier = PersistentIdentifier.get_by_object(
            pid_type='depid', object_type='rec', object_uuid=item.id)
        record_class = import_string('weko_deposit.api:WekoRecord')
        resolver = Resolver(pid_type='recid',
                            object_type='rec',
                            getter=record_class.get_record)
        pid, approval_record = resolver.resolve(pid_identifier.pid_value)

        files = to_files_js(approval_record)

        # get files data after click Save btn
        sessionstore = RedisStore(
            redis.StrictRedis.from_url('redis://{host}:{port}/1'.format(
                host=os.getenv('INVENIO_REDIS_HOST', 'localhost'),
                port=os.getenv('INVENIO_REDIS_PORT', '6379'))))
        if sessionstore.redis.exists('activity_item_' + str(activity_id)):
            item_str = sessionstore.get('activity_item_' + str(activity_id))
            item_json = json.loads(item_str.decode('utf-8'))
            if 'files' in item_json:
                files = item_json.get('files')
        if not files:
            deposit = WekoDeposit.get_record(item.id)
            if deposit:
                files = to_files_js(deposit)

        if files and not files_thumbnail:
            files_thumbnail = [
                i for i in files
                if 'is_thumbnail' in i.keys() and i['is_thumbnail']
            ]

        from weko_deposit.links import base_factory
        links = base_factory(pid)

    res_check = check_authority_action(str(activity_id), str(action_id))

    getargs = request.args
    ctx = {'community': None}
    community_id = ""
    if 'community' in getargs:
        comm = GetCommunity.get_community_by_id(request.args.get('community'))
        ctx = {'community': comm}
        community_id = comm.id
    # be use for index tree and comment page.
    if 'item_login' == action_endpoint or 'file_upload' == action_endpoint:
        session['itemlogin_id'] = activity_id
        session['itemlogin_activity'] = activity_detail
        session['itemlogin_item'] = item
        session['itemlogin_steps'] = steps
        session['itemlogin_action_id'] = action_id
        session['itemlogin_cur_step'] = cur_step
        session['itemlogin_record'] = approval_record
        session['itemlogin_histories'] = histories
        session['itemlogin_res_check'] = res_check
        session['itemlogin_pid'] = pid
        session['itemlogin_community_id'] = community_id

    from weko_theme.utils import get_design_layout
    # Get the design for widget rendering
    page, render_widgets = get_design_layout(
        community_id or current_app.config['WEKO_THEME_DEFAULT_COMMUNITY'])
    list_license = get_list_licence()

    if item and item.get('pid'):
        pid_without_ver = item['pid']['value'].split('.')[0]
        item_link = ItemLink.get_item_link_info(pid_without_ver)
        ctx['item_link'] = item_link

    return render_template(
        'weko_workflow/activity_detail.html',
        page=page,
        render_widgets=render_widgets,
        activity=activity_detail,
        item=item,
        steps=steps,
        action_id=action_id,
        cur_step=cur_step,
        temporary_comment=temporary_comment,
        temporary_journal=temporary_journal,
        temporary_idf_grant=temporary_identifier_select,
        temporary_idf_grant_suffix=temporary_identifier_inputs,
        idf_grant_data=identifier_setting,
        idf_grant_input=IDENTIFIER_GRANT_LIST,
        idf_grant_method=IDENTIFIER_GRANT_SUFFIX_METHOD,
        record=approval_record,
        records=record,
        step_item_login_url=step_item_login_url,
        need_file=need_file,
        need_billing_file=need_billing_file,
        jsonschema=json_schema,
        schemaform=schema_form,
        id=workflow_detail.itemtype_id,
        item_save_uri=item_save_uri,
        files=files,
        endpoints=endpoints,
        error_type='item_login_error',
        links=links,
        histories=histories,
        res_check=res_check,
        pid=pid,
        community_id=community_id,
        need_thumbnail=need_thumbnail,
        files_thumbnail=files_thumbnail,
        allow_multi_thumbnail=allow_multi_thumbnail,
        enable_feedback_maillist=current_app.
        config['WEKO_WORKFLOW_ENABLE_FEEDBACK_MAIL'],
        enable_contributor=current_app.
        config['WEKO_WORKFLOW_ENABLE_CONTRIBUTOR'],
        show_automatic_metadata_input=show_autofill_metadata,
        is_hidden_pubdate=is_hidden_pubdate_value,
        list_license=list_license,
        **ctx)
Ejemplo n.º 60
0
def setup():
    """Load query object for given database type."""
    from werkzeug.utils import import_string
    from invenio.config import CFG_DATABASE_TYPE
    return import_string(
        'invenio.legacy.dbquery_{0}'.format(CFG_DATABASE_TYPE))