IntenseWebs/pgadmin4
3
0
Fork 0
mirror of https://github.com/pgadmin-org/pgadmin4.git synced 2025-02-25 18:55:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

Removing dynamic module loading and replacing it with static loading. Fixes #7492

Browse Source 
Gets rid of all occurrences and usage of get_own_javascripts since it is no longer used.
This commit is contained in:
Aditya Toshniwal 2022-06-30 11:06:50 +05:30 committed by Akshay Joshi
parent e46468321d
commit cb635f6706
51 changed files with 490 additions and 550 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/en_US/release_notes.rst
View File

@ -11,6 +11,7 @@ notes for it.
.. toctree::
:maxdepth: 1
release_notes_6_12
release_notes_6_11
release_notes_6_10
release_notes_6_9

19
docs/en_US/release_notes_6_12.rst Normal file
View File

@ -0,0 +1,19 @@
************
Version 6.12
************
Release date: 2022-07-28
This release contains a number of bug fixes and new features since the release of pgAdmin 4 v6.11.
New features
************
Housekeeping
************
| `Issue #7492 <https://redmine.postgresql.org/issues/7492>`_ - Removing dynamic module loading and replacing it with static loading.
Bug fixes
*********

3
web/pgadmin/__init__.py
View File

@ -713,7 +713,8 @@ def create_app(app_name=None):
##########################################################################
# Load plugin modules
##########################################################################
for module in app.find_submodules('pgadmin'):
from .submodules import get_submodules
for module in get_submodules():
app.logger.info('Registering blueprint module: %s' % module)
if app.blueprints.get(module.name) is None:
app.register_blueprint(module)

7
web/pgadmin/about/__init__.py
View File

@ -41,13 +41,6 @@ class AboutModule(PgAdminModule):
]
}
def get_own_javascripts(self):
return [{
'name': 'pgadmin.about',
'path': url_for('about.index') + 'about',
'when': None
}]
def get_exposed_url_endpoints(self):
return ['about.index']

25
web/pgadmin/authenticate/mfa/registry.py
View File

@ -22,8 +22,31 @@ class: MultiFactorAuthRegistry
An registry factory for the multi-factor authentication methods.
"""
@classmethod
def load_modules(cls, app=None):
submodules = []
from . import authenticator as module
submodules.append(module)
from . import email as module
submodules.append(module)
from . import utils as module
submodules.append(module)
from . import views as module
submodules.append(module)
for module in submodules:
if "init_app" in module.__dict__.keys():
module.__dict__["init_app"](app)
MultiFactorAuthRegistry = create_registry_metaclass(
'MultiFactorAuthRegistry', __package__, decorate_as_module=True
'MultiFactorAuthRegistry', __package__, load_modules=load_modules,
decorate_as_module=True
)

29
web/pgadmin/authenticate/registry.py
View File

@ -13,6 +13,33 @@
from pgadmin.utils.dynamic_registry import create_registry_metaclass
@classmethod
def load_modules(cls, app=None):
submodules = []
from . import internal as module
submodules.append(module)
from . import kerberos as module
submodules.append(module)
from . import ldap as module
submodules.append(module)
from . import mfa as module
submodules.append(module)
from . import oauth2 as module
submodules.append(module)
from . import webserver as module
submodules.append(module)
for module in submodules:
if "init_app" in module.__dict__.keys():
module.__dict__["init_app"](app)
AuthSourceRegistry = create_registry_metaclass(
"AuthSourceRegistry", __package__, decorate_as_module=True
"AuthSourceRegistry", __package__, load_modules=load_modules,
decorate_as_module=True
)

159
web/pgadmin/browser/__init__.py
View File

@ -102,103 +102,6 @@ class BrowserModule(PgAdminModule):
stylesheets.append(url_for(endpoint, filename=filename))
return stylesheets
def get_own_javascripts(self):
scripts = list()
scripts.append({
'name': 'alertify',
'path': url_for(
'static',
filename='vendor/alertifyjs/alertify' if current_app.debug
else 'vendor/alertifyjs/alertify.min'
),
'exports': 'alertify',
'preloaded': True
})
scripts.append({
'name': 'jqueryui.position',
'path': url_for(
'static',
filename='vendor/jQuery-contextMenu/jquery.ui.position' if
current_app.debug else
'vendor/jQuery-contextMenu/jquery.ui.position.min'
),
'deps': ['jquery'],
'exports': 'jQuery.ui.position',
'preloaded': True
})
scripts.append({
'name': 'jquery.contextmenu',
'path': url_for(
'static',
filename='vendor/jQuery-contextMenu/jquery.contextMenu' if
current_app.debug else
'vendor/jQuery-contextMenu/jquery.contextMenu.min'
),
'deps': ['jquery', 'jqueryui.position'],
'exports': 'jQuery.contextMenu',
'preloaded': True
})
scripts.append({
'name': 'wcdocker',
'path': url_for(
'static',
filename='vendor/wcDocker/wcDocker' if current_app.debug
else 'vendor/wcDocker/wcDocker.min'
),
'deps': ['jquery.contextmenu'],
'exports': '',
'preloaded': True
})
scripts.append({
'name': 'pgadmin.browser.datamodel',
'path': url_for(BROWSER_STATIC, filename='js/datamodel'),
'preloaded': True
})
for name, script in [
[PGADMIN_BROWSER, 'js/browser'],
['pgadmin.browser.endpoints', 'js/endpoints'],
['pgadmin.browser.error', 'js/error'],
['pgadmin.browser.constants', 'js/constants']
]:
scripts.append({
'name': name,
'path': url_for(BROWSER_INDEX) + script,
'preloaded': True
})
for name, script in [
['pgadmin.browser.node', 'js/node'],
['pgadmin.browser.messages', 'js/messages'],
['pgadmin.browser.collection', 'js/collection']
]:
scripts.append({
'name': name,
'path': url_for(BROWSER_INDEX) + script,
'preloaded': True,
'deps': ['pgadmin.browser.datamodel']
})
for name, end in [
['pgadmin.browser.menu', 'js/menu'],
['pgadmin.browser.panel', 'js/panel'],
['pgadmin.browser.frame', 'js/frame']
]:
scripts.append({
'name': name, 'path': url_for(BROWSER_STATIC, filename=end),
'preloaded': True})
scripts.append({
'name': 'pgadmin.browser.node.ui',
'path': url_for(BROWSER_STATIC, filename='js/node.ui'),
'when': 'server_group'
})
for module in self.submodules:
scripts.extend(module.get_own_javascripts())
return scripts
def get_own_menuitems(self):
menus = {
'file_items': [
@ -311,6 +214,15 @@ class BrowserModule(PgAdminModule):
'browser.lock_layout',
'browser.signal_runtime']
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .server_groups import blueprint as module
self.submodules.append(module)
super(BrowserModule, self).register(app, options)
blueprint = BrowserModule(MODULE_NAME, __name__)
@ -377,51 +289,6 @@ class BrowserPluginModule(PgAdminModule):
"""
return False
def get_own_javascripts(self):
"""
Returns the list of javascripts information used by the module.
Each javascripts information must contain name, path of the script.
The name must be unique for each module, hence - in order to refer them
properly, we do use 'pgadmin.node.<type>' as norm.
That can also refer to when to load the script.
i.e.
We may not need to load the javascript of table node, when we're
not yet connected to a server, and no database is loaded. Hence - it
make sense to load them when a database is loaded.
We may also add 'deps', which also refers to the list of javascripts,
it may depends on.
"""
scripts = []
if self.module_use_template_javascript:
scripts.extend([{
'name': PGADMIN_NODE % self.node_type,
'path': url_for(BROWSER_INDEX
) + '%s/module' % self.node_type,
'when': self.script_load,
'is_template': True
}])
else:
scripts.extend([{
'name': PGADMIN_NODE % self.node_type,
'path': url_for(
'%s.static' % self.name,
filename=('js/%s' % self.node_type)
),
'when': self.script_load,
'is_template': False
}])
for module in self.submodules:
scripts.extend(module.get_own_javascripts())
return scripts
def generate_browser_node(
self, node_id, parent_id, label, icon, inode, node_type, **kwargs
):
@ -508,14 +375,6 @@ class BrowserPluginModule(PgAdminModule):
"""
return self.browser_url_prefix + self.node_type
@property
def javascripts(self):
"""
Override the javascript of PgAdminModule, so that - we don't return
javascripts from the get_own_javascripts itself.
"""
return []
@property
def label(self):
"""

27
web/pgadmin/browser/collection.py
View File

@ -59,33 +59,6 @@ class CollectionNodeModule(PgAdminModule, PGChildModule):
"""
return True
def get_own_javascripts(self):
scripts = []
if self.module_use_template_javascript:
scripts.extend([{
'name': PGADMIN_NODE % self.node_type,
'path': url_for('browser.index'
) + '%s/module' % self.node_type,
'when': self.script_load,
'is_template': True
}])
else:
scripts.extend([{
'name': PGADMIN_NODE % self.node_type,
'path': url_for(
'%s.static' % self.name,
filename=('js/%s' % self.node_type)
),
'when': self.script_load,
'is_template': False
}])
for module in self.submodules:
scripts.extend(module.get_own_javascripts())
return scripts
def generate_browser_node(
self, node_id, parent_id, label, icon, **kwargs
):

9
web/pgadmin/browser/server_groups/__init__.py
View File

@ -123,6 +123,15 @@ class ServerGroupModule(BrowserPluginModule):
"""
pass
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .servers import blueprint as module
self.submodules.append(module)
super(BrowserPluginModule, self).register(app, options)
class ServerGroupMenuItem(MenuItem):
def __init__(self, **kwargs):

41
web/pgadmin/browser/server_groups/servers/__init__.py
View File

@ -283,30 +283,6 @@ class ServerModule(sg.ServerGroupPluginModule):
return snippets
def get_own_javascripts(self):
scripts = []
scripts.extend([{
'name': 'pgadmin.browser.server.privilege',
'path': url_for('%s.static' % self.name, filename='js/privilege'),
'when': self.node_type,
'is_template': False,
'deps': ['pgadmin.browser.node.ui']
}, {
'name': 'pgadmin.browser.server.variable',
'path': url_for('%s.static' % self.name, filename='js/variable'),
'when': self.node_type,
'is_template': False
}, {
'name': 'pgadmin.server.supported_servers',
'path': url_for('browser.index') + 'server/supported_servers',
'is_template': True,
'when': self.node_type
}])
scripts.extend(sg.ServerGroupPluginModule.get_own_javascripts(self))
return scripts
def register(self, app, options):
"""
Override the default register function to automagically register
@ -318,6 +294,23 @@ class ServerModule(sg.ServerGroupPluginModule):
app.jinja_env.filters['qtTypeIdent'] = driver.qtTypeIdent
app.jinja_env.filters['hasAny'] = has_any
from .ppas import PPAS
from .databases import blueprint as module
self.submodules.append(module)
from .pgagent import blueprint as module
self.submodules.append(module)
from .resource_groups import blueprint as module
self.submodules.append(module)
from .roles import blueprint as module
self.submodules.append(module)
from .tablespaces import blueprint as module
self.submodules.append(module)
super(ServerModule, self).register(app, options)
# We do not have any preferences for server node.

34
web/pgadmin/browser/server_groups/servers/databases/__init__.py
View File

@ -95,6 +95,40 @@ class DatabaseModule(CollectionNodeModule):
"""
return False
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .casts import blueprint as module
self.submodules.append(module)
from .event_triggers import blueprint as module
self.submodules.append(module)
from .extensions import blueprint as module
self.submodules.append(module)
from .foreign_data_wrappers import blueprint as module
self.submodules.append(module)
from .languages import blueprint as module
self.submodules.append(module)
from .publications import blueprint as module
self.submodules.append(module)
from .schemas import schema_blueprint as module
self.submodules.append(module)
from .schemas import catalog_blueprint as module
self.submodules.append(module)
from .subscriptions import blueprint as module
self.submodules.append(module)
super(DatabaseModule, self).register(app, options)
blueprint = DatabaseModule(__name__)

9
web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/__init__.py
View File

@ -95,6 +95,15 @@ class ForeignDataWrapperModule(CollectionNodeModule):
"""
return False
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .foreign_servers import blueprint as module
self.submodules.append(module)
super(ForeignDataWrapperModule, self).register(app, options)
blueprint = ForeignDataWrapperModule(__name__)

9
web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/__init__.py
View File

@ -96,6 +96,15 @@ class ForeignServerModule(CollectionNodeModule):
"""
return False
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .user_mappings import blueprint as module
self.submodules.append(module)
super(ForeignServerModule, self).register(app, options)
blueprint = ForeignServerModule(__name__)

74
web/pgadmin/browser/server_groups/servers/databases/schemas/__init__.py
View File

@ -103,6 +103,73 @@ class SchemaModule(CollectionNodeModule):
"""
return False
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .aggregates import blueprint as module
self.submodules.append(module)
from .catalog_objects import blueprint as module
self.submodules.append(module)
from .collations import blueprint as module
self.submodules.append(module)
from .domains import blueprint as module
self.submodules.append(module)
from .foreign_tables import blueprint as module
self.submodules.append(module)
from .fts_configurations import blueprint as module
self.submodules.append(module)
from .fts_dictionaries import blueprint as module
self.submodules.append(module)
from .fts_parsers import blueprint as module
self.submodules.append(module)
from .fts_templates import blueprint as module
self.submodules.append(module)
from .functions import blueprint as module
self.submodules.append(module)
from .functions import trigger_function_blueprint as module
self.submodules.append(module)
from .functions import procedure_blueprint as module
self.submodules.append(module)
from .operators import blueprint as module
self.submodules.append(module)
from .packages import blueprint as module
self.submodules.append(module)
from .sequences import blueprint as module
self.submodules.append(module)
from .synonyms import blueprint as module
self.submodules.append(module)
from .tables import blueprint as module
self.submodules.append(module)
from .types import blueprint as module
self.submodules.append(module)
from .views import view_blueprint as module
self.submodules.append(module)
from .views import mview_blueprint as module
self.submodules.append(module)
super(SchemaModule, self).register(app, options)
class CatalogModule(SchemaModule):
"""
@ -114,6 +181,13 @@ class CatalogModule(SchemaModule):
_NODE_TYPE = 'catalog'
_COLLECTION_LABEL = gettext("Catalogs")
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
super(SchemaModule, self).register(app, options)
schema_blueprint = SchemaModule(__name__)
catalog_blueprint = CatalogModule(__name__)

10
web/pgadmin/browser/server_groups/servers/databases/schemas/catalog_objects/__init__.py
View File

@ -80,6 +80,16 @@ class CatalogObjectModule(SchemaChildModule):
"""
return database.DatabaseModule.node_type
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
super(CatalogObjectModule, self).register(app, options)
from .columns import blueprint as module
app.register_blueprint(module)
blueprint = CatalogObjectModule(__name__)

9
web/pgadmin/browser/server_groups/servers/databases/schemas/domains/__init__.py
View File

@ -71,6 +71,15 @@ class DomainModule(SchemaChildModule):
"""
return databases.DatabaseModule.node_type
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .domain_constraints import blueprint as module
self.submodules.append(module)
super(DomainModule, self).register(app, options)
blueprint = DomainModule(__name__)

12
web/pgadmin/browser/server_groups/servers/databases/schemas/packages/__init__.py
View File

@ -76,6 +76,18 @@ class PackageModule(SchemaChildModule):
"""
return database.DatabaseModule.node_type
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .edbfuncs import blueprint as module
self.submodules.append(module)
from .edbvars import blueprint as module
self.submodules.append(module)
super(PackageModule, self).register(app, options)
blueprint = PackageModule(__name__)

37
web/pgadmin/browser/server_groups/servers/databases/schemas/tables/__init__.py
View File

@ -118,17 +118,36 @@ class TableModule(SchemaChildModule):
return snippets
def get_own_javascripts(self):
scripts = SchemaChildModule.get_own_javascripts(self)
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .columns import blueprint as module
self.submodules.append(module)
scripts.append({
'name': 'pgadmin.browser.table.partition.utils',
'path': url_for('browser.index') +
'table/static/js/partition.utils',
'when': 'database', 'is_template': False
})
from .compound_triggers import blueprint as module
self.submodules.append(module)
return scripts
from .constraints import blueprint as module
self.submodules.append(module)
from .indexes import blueprint as module
self.submodules.append(module)
from .partitions import blueprint as module
self.submodules.append(module)
from .row_security_policies import blueprint as module
self.submodules.append(module)
from .rules import blueprint as module
self.submodules.append(module)
from .triggers import blueprint as module
self.submodules.append(module)
super(TableModule, self).register(app, options)
blueprint = TableModule(__name__)

22
web/pgadmin/browser/server_groups/servers/databases/schemas/tables/constraints/__init__.py
View File

@ -83,6 +83,28 @@ class ConstraintsModule(CollectionNodeModule):
"""
return False
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .check_constraint import blueprint as module
self.submodules.append(module)
from .exclusion_constraint import blueprint as module
self.submodules.append(module)
from .foreign_key import blueprint as module
self.submodules.append(module)
from .index_constraint import primary_key_blueprint as module
self.submodules.append(module)
from .index_constraint import unique_constraint_blueprint as module
self.submodules.append(module)
super(ConstraintsModule, self).register(app, options)
blueprint = ConstraintsModule(__name__)

6
web/pgadmin/browser/server_groups/servers/databases/schemas/tables/partitions/__init__.py
View File

@ -122,13 +122,9 @@ class PartitionsModule(CollectionNodeModule):
sub-modules of table node under partition table node.
"""
self.submodules = list(app.find_submodules(self.import_name))
self.submodules = []
super(CollectionNodeModule, self).register(app, options)
for module in self.submodules:
module.parentmodules.append(self)
app.register_blueprint(module)
# Now add sub modules of table node to partition table node.
# Exclude 'partition' module for now to avoid cyclic import issue.
modules_to_skip = ['partition', 'column']

19
web/pgadmin/browser/server_groups/servers/databases/schemas/views/__init__.py
View File

@ -130,6 +130,25 @@ class ViewModule(SchemaChildModule):
return snippets
def register(self, app, options):
from pgadmin.browser.server_groups.servers.databases.schemas.\
tables.columns import blueprint as module
self.submodules.append(module)
from pgadmin.browser.server_groups.servers.databases.schemas.\
tables.indexes import blueprint as module
self.submodules.append(module)
from pgadmin.browser.server_groups.servers.databases.schemas.\
tables.triggers import blueprint as module
self.submodules.append(module)
from pgadmin.browser.server_groups.servers.databases.schemas.\
tables.rules import blueprint as module
self.submodules.append(module)
from pgadmin.browser.server_groups.servers.databases.schemas.\
tables.compound_triggers import blueprint as module
self.submodules.append(module)
super(ViewModule, self).register(app, options)
class Message(IProcessDesc):
def __init__(self, _sid, _data, _query):

13
web/pgadmin/browser/server_groups/servers/pgagent/__init__.py
View File

@ -111,6 +111,19 @@ SELECT EXISTS(
"""
return False
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .schedules import blueprint as module
self.submodules.append(module)
from .steps import blueprint as module
self.submodules.append(module)
super(JobModule, self).register(app, options)
blueprint = JobModule(__name__)

7
web/pgadmin/dashboard/__init__.py
View File

@ -36,13 +36,6 @@ class DashboardModule(PgAdminModule):
def get_own_menuitems(self):
return {}
def get_own_javascripts(self):
return [{
'name': 'pgadmin.dashboard',
'path': url_for('dashboard.index') + 'dashboard',
'when': None
}]
def get_own_stylesheets(self):
"""
Returns:

44
web/pgadmin/misc/__init__.py
View File

@ -29,22 +29,6 @@ MODULE_NAME = 'misc'
class MiscModule(PgAdminModule):
LABEL = gettext('Miscellaneous')
def get_own_javascripts(self):
return [
{
'name': 'pgadmin.misc.explain',
'path': url_for('misc.index') + 'explain/explain',
'preloaded': False
}, {
'name': 'snap.svg',
'path': url_for(
'misc.static', filename='explain/vendor/snap.svg/' + (
'snap.svg' if config.DEBUG else 'snap.svg-min'
)),
'preloaded': False
}
]
def get_own_stylesheets(self):
stylesheets = []
return stylesheets
@ -110,6 +94,34 @@ class MiscModule(PgAdminModule):
return ['misc.ping', 'misc.index', 'misc.cleanup',
'misc.validate_binary_path']
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
from .bgprocess import blueprint as module
self.submodules.append(module)
from .cloud import blueprint as module
self.submodules.append(module)
from .dependencies import blueprint as module
self.submodules.append(module)
from .dependents import blueprint as module
self.submodules.append(module)
from .file_manager import blueprint as module
self.submodules.append(module)
from .sql import blueprint as module
self.submodules.append(module)
from .statistics import blueprint as module
self.submodules.append(module)
super(MiscModule, self).register(app, options)
# Initialise the module
blueprint = MiscModule(MODULE_NAME, __name__)

7
web/pgadmin/misc/bgprocess/__init__.py
View File

@ -23,13 +23,6 @@ MODULE_NAME = 'bgprocess'
class BGProcessModule(PgAdminModule):
def get_own_javascripts(self):
return [{
'name': 'pgadmin.browser.bgprocess',
'path': url_for('bgprocess.static', filename='js/bgprocess'),
'when': None
}]
def get_own_stylesheets(self):
"""
Returns:

34
web/pgadmin/misc/cloud/__init__.py
View File

@ -51,24 +51,6 @@ class CloudModule(PgAdminModule):
stylesheets = []
return stylesheets
def get_own_javascripts(self):
""""
Returns:
list: js files used by this module
"""
scripts = []
scripts.append({
'name': 'pgadmin.misc.cloud',
'path': url_for('cloud.index') + 'cloud',
'when': None
})
scripts.append({
'name': 'pgadmin.browser.wizard',
'path': url_for('browser.static', filename='js/wizard'),
'when': None
})
return scripts
def get_exposed_url_endpoints(self):
"""
Returns:
@ -80,6 +62,22 @@ class CloudModule(PgAdminModule):
'cloud.get_host_ip',
'cloud.clear_cloud_session']
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
super(CloudModule, self).register(app, options)
from .azure import blueprint as module
app.register_blueprint(module)
from .biganimal import blueprint as module
app.register_blueprint(module)
from .rds import blueprint as module
app.register_blueprint(module)
# Create blueprint for CloudModule class
blueprint = CloudModule(

8
web/pgadmin/misc/dependencies/__init__.py
View File

@ -16,13 +16,7 @@ MODULE_NAME = 'dependencies'
class DependenciesModule(PgAdminModule):
def get_own_javascripts(self):
return [{
'name': 'pgadmin.browser.dependencies',
'path': url_for('dependencies.static',
filename='js/dependencies'),
'when': None
}]
pass
# Initialise the module

7
web/pgadmin/misc/dependents/__init__.py
View File

@ -16,12 +16,7 @@ MODULE_NAME = 'dependents'
class DependentsModule(PgAdminModule):
def get_own_javascripts(self):
return [{
'name': 'pgadmin.browser.dependents',
'path': url_for('dependents.static', filename='js/dependents'),
'when': None
}]
pass
# Initialise the module

9
web/pgadmin/misc/file_manager/__init__.py
View File

@ -116,15 +116,6 @@ class FileManagerModule(PgAdminModule):
LABEL = gettext("Storage")
def get_own_javascripts(self):
return [
{
'name': 'pgadmin.file_manager',
'path': url_for('file_manager.index') + 'file_manager',
'when': None
},
]
def get_own_stylesheets(self):
return [
url_for('static', filename='vendor/jquery.dropzone/dropzone.css')

7
web/pgadmin/misc/sql/__init__.py
View File

@ -20,13 +20,6 @@ MODULE_NAME = 'sql'
class SQLModule(PgAdminModule):
def get_own_javascripts(self):
return [{
'name': 'pgadmin.browser.object_sql',
'path': url_for('sql.static', filename='js/sql'),
'when': None
}]
def get_exposed_url_endpoints(self):
"""
Returns:

8
web/pgadmin/misc/statistics/__init__.py
View File

@ -22,13 +22,7 @@ class StatisticsModule(PgAdminModule):
This module will render the statistics of the browser nodes on selection
when statistics panel is active.
"""
def get_own_javascripts(self):
return [{
'name': 'pgadmin.browser.object_statistics',
'path': url_for('statistics.static', filename='js/statistics'),
'when': None
}]
pass
# Initialise the module

13
web/pgadmin/preferences/__init__.py
View File

@ -36,19 +36,6 @@ class PreferencesModule(PgAdminModule):
And, allows the user to modify (not add/remove) as per their requirement.
"""
def get_own_javascripts(self):
scripts = list()
for name, script in [
['pgadmin.preferences', 'js/preferences']
]:
scripts.append({
'name': name,
'path': url_for('preferences.index') + script,
'when': None
})
return scripts
def get_own_stylesheets(self):
return []

7
web/pgadmin/settings/__init__.py
View File

@ -28,13 +28,6 @@ MODULE_NAME = 'settings'
class SettingsModule(PgAdminModule):
def get_own_javascripts(self):
return [{
'name': 'pgadmin.settings',
'path': url_for('settings.index') + 'settings',
'when': None
}]
def get_own_menuitems(self):
return {
'file_items': [

2
web/pgadmin/static/bundle/app.js
View File

@ -24,7 +24,7 @@ define('app', [
}
else if (module && module.Init && typeof module.Init == 'function') {
try {
module.init();
module.Init();
}
catch (e) {
console.warn(e.stack || e);

26
web/pgadmin/submodules.py Normal file
View File

@ -0,0 +1,26 @@
from .about import blueprint as AboutModule
from .authenticate import blueprint as AuthenticateModule
from .browser import blueprint as BrowserModule
from .dashboard import blueprint as DashboardModule
from .help import blueprint as HelpModule
from .misc import blueprint as MiscModule
from .preferences import blueprint as PreferencesModule
from .redirects import blueprint as RedirectModule
from .settings import blueprint as SettingsModule
from .tools import blueprint as ToolsModule
def get_submodules():
return [
AboutModule,
AuthenticateModule,
BrowserModule,
DashboardModule,
DashboardModule,
HelpModule,
MiscModule,
PreferencesModule,
RedirectModule,
SettingsModule,
ToolsModule
]

75
web/pgadmin/tools/__init__.py
View File

@ -21,33 +21,54 @@ MODULE_NAME = 'tools'
class ToolsModule(PgAdminModule):
def get_own_javascripts(self):
return [{
'name': 'translations',
'path': url_for('tools.index') + "translations",
'when': None
}, {
'name': 'pgadmin-sqlfoldcode',
'path': url_for(
'static',
filename='js/codemirror/addon/fold/pgadmin-sqlfoldcode'
),
'when': 'debugger'
}, {
'name': 'slick.pgadmin.editors',
'path': url_for(
'static',
filename='js/slickgrid/slick.pgadmin.editors'
),
'when': 'debugger'
}, {
'name': 'slick.pgadmin.formatters',
'path': url_for(
'static',
filename='js/slickgrid/slick.pgadmin.formatters'
),
'when': 'debugger'
}]
def register(self, app, options):
"""
Override the default register function to automagically register
sub-modules at once.
"""
super(PgAdminModule, self).register(app, options)
from .backup import blueprint as module
app.register_blueprint(module)
from .debugger import blueprint as module
app.register_blueprint(module)
from .erd import blueprint as module
app.register_blueprint(module)
from .grant_wizard import blueprint as module
app.register_blueprint(module)
from .import_export import blueprint as module
app.register_blueprint(module)
from .import_export_servers import blueprint as module
app.register_blueprint(module)
from .maintenance import blueprint as module
app.register_blueprint(module)
from .psql import blueprint as module
app.register_blueprint(module)
from .restore import blueprint as module
app.register_blueprint(module)
from .schema_diff import blueprint as module
app.register_blueprint(module)
from .search_objects import blueprint as module
app.register_blueprint(module)
from .sqleditor import blueprint as module
app.register_blueprint(module)
from .storage_manager import blueprint as module
app.register_blueprint(module)
from .user_management import blueprint as module
app.register_blueprint(module)
# Initialise the module

11
web/pgadmin/tools/backup/__init__.py
View File

@ -44,17 +44,6 @@ class BackupModule(PgAdminModule):
LABEL = _('Backup')
def get_own_javascripts(self):
""""
Returns:
list: js files used by this module
"""
return [{
'name': 'pgadmin.tools.backup',
'path': url_for('backup.index') + 'backup',
'when': None
}]
def show_system_objects(self):
"""
return system preference objects

22
web/pgadmin/tools/debugger/__init__.py
View File

@ -53,31 +53,9 @@ class DebuggerModule(PgAdminModule):
class DebuggerModule(PgAdminModule)
A module class for debugger which is derived from PgAdminModule.
Methods:
-------
* get_own_javascripts(self)
- Method is used to load the required javascript files for debugger
module
"""
LABEL = gettext("Debugger")
def get_own_javascripts(self):
scripts = list()
for name, script in [
['pgadmin.tools.debugger', 'js/index'],
['pgadmin.tools.debugger.controller', 'js/debugger'],
['pgadmin.tools.debugger.ui', 'js/debugger_ui'],
]:
scripts.append({
'name': name,
'path': url_for('debugger.index') + script,
'when': None
})
return scripts
def register_preferences(self):
self.preference.register(
'keyboard_shortcuts', 'btn_start',

7
web/pgadmin/tools/erd/__init__.py
View File

@ -47,13 +47,6 @@ class ERDModule(PgAdminModule):
def get_own_menuitems(self):
return {}
def get_own_javascripts(self):
return [{
'name': 'pgadmin.erd',
'path': url_for('erd.index') + "erd",
'when': None
}]
def get_panels(self):
return []

18
web/pgadmin/tools/grant_wizard/__init__.py
View File

@ -52,24 +52,6 @@ class GrantWizardModule(PgAdminModule):
stylesheets = []
return stylesheets
def get_own_javascripts(self):
""""
Returns:
list: js files used by this module
"""
scripts = []
scripts.append({
'name': 'pgadmin.tools.grant_wizard',
'path': url_for('grant_wizard.index') + 'grant_wizard',
'when': None
})
scripts.append({
'name': 'pgadmin.browser.wizard',
'path': url_for('browser.static', filename='js/wizard'),
'when': None
})
return scripts
def show_system_objects(self):
"""
return system preference objects

18
web/pgadmin/tools/import_export/__init__.py
View File

@ -33,28 +33,10 @@ class ImportExportModule(PgAdminModule):
class ImportExportModule(PgAdminModule)
A module class for import which is derived from PgAdminModule.
Methods:
-------
* get_own_javascripts(self)
- Method is used to load the required javascript files for import module
"""
LABEL = _('Import/Export')
def get_own_javascripts(self):
scripts = list()
for name, script in [
['pgadmin.tools.import_export', 'js/import_export']
]:
scripts.append({
'name': name,
'path': url_for('import_export.index') + script,
'when': None
})
return scripts
def get_exposed_url_endpoints(self):
"""
Returns:

18
web/pgadmin/tools/import_export_servers/__init__.py
View File

@ -35,28 +35,10 @@ class ImportExportServersModule(PgAdminModule):
class ImportExportServersModule(PgAdminModule)
A module class for import which is derived from PgAdminModule.
Methods:
-------
* get_own_javascripts(self)
- Method is used to load the required javascript files for import module
"""
LABEL = _('Import/Export Servers')
def get_own_javascripts(self):
scripts = list()
for name, script in [
['pgadmin.tools.import_export_servers', 'js/import_export_servers']
]:
scripts.append({
'name': name,
'path': url_for('import_export_servers.index') + script,
'when': None
})
return scripts
def get_exposed_url_endpoints(self):
"""
Returns:

21
web/pgadmin/tools/maintenance/__init__.py
View File

@ -32,30 +32,9 @@ class MaintenanceModule(PgAdminModule):
A module class for maintenance tools of vacuum which is derived from
PgAdminModule.
Methods:
-------
* get_own_javascripts()
- Method is used to load the required javascript files for maintenance
tool module
* get_own_stylesheets()
- Returns the list of CSS file used by Maintenance module
"""
LABEL = _('Maintenance')
def get_own_javascripts(self):
scripts = list()
for name, script in [
['pgadmin.tools.maintenance', 'js/maintenance']
]:
scripts.append({
'name': name,
'path': url_for('maintenance.index') + script,
'when': None
})
return scripts
def get_own_stylesheets(self):
"""
Returns:

7
web/pgadmin/tools/psql/__init__.py
View File

@ -55,13 +55,6 @@ class PSQLModule(PgAdminModule):
def get_own_menuitems(self):
return {}
def get_own_javascripts(self):
return [{
'name': 'pgadmin.psql',
'path': url_for('psql.index') + "psql",
'when': None
}]
def get_panels(self):
return []

11
web/pgadmin/tools/restore/__init__.py
View File

@ -41,17 +41,6 @@ class RestoreModule(PgAdminModule):
LABEL = _('Restore')
def get_own_javascripts(self):
""""
Returns:
list: js files used by this module
"""
return [{
'name': 'pgadmin.tools.restore',
'path': url_for('restore.index') + 'restore',
'when': None
}]
def get_exposed_url_endpoints(self):
"""
Returns:

7
web/pgadmin/tools/schema_diff/__init__.py
View File

@ -45,13 +45,6 @@ class SchemaDiffModule(PgAdminModule):
def get_own_menuitems(self):
return {}
def get_own_javascripts(self):
return [{
'name': 'pgadmin.schema_diff',
'path': url_for('schema_diff.index') + "schema_diff",
'when': None
}]
def get_panels(self):
return []

17
web/pgadmin/tools/storage_manager/__init__.py
View File

@ -30,23 +30,6 @@ class StorageManagerModule(PgAdminModule):
LABEL = _('Storage Manager')
def get_own_javascripts(self):
""""
Returns:
list: js files used by this module
"""
scripts = list()
for name, script in [
['pgadmin.tools.storage_manager', 'js/storage_manager']
]:
scripts.append({
'name': name,
'path': url_for('storage_manager.index') + script,
'when': None
})
return scripts
blueprint = StorageManagerModule(MODULE_NAME, __name__)

16
web/pgadmin/tools/user_management/__init__.py
View File

@ -46,22 +46,6 @@ class UserManagementModule(PgAdminModule):
LABEL = _('Users')
def get_own_javascripts(self):
""""
Returns:
list: js files used by this module
"""
return [{
'name': 'pgadmin.tools.user_management',
'path': url_for('user_management.index') + 'user_management',
'when': None
}, {
'name': 'pgadmin.user_management.current_user',
'path': url_for('user_management.index') + 'current_user',
'when': None,
'is_template': True
}]
def show_system_objects(self):
"""
return system preference objects

17
web/pgadmin/utils/__init__.py
View File

@ -68,8 +68,6 @@ class PgAdminModule(Blueprint):
sub-modules at once.
"""
self.submodules = list(app.find_submodules(self.import_name))
super(PgAdminModule, self).register(app, options)
for module in self.submodules:
@ -94,14 +92,6 @@ class PgAdminModule(Blueprint):
"""
return dict()
def get_own_javascripts(self):
"""
Returns:
list: the javascripts used by this module, not including
any script needed by the submodules.
"""
return []
def get_own_menuitems(self):
"""
Returns:
@ -139,13 +129,6 @@ class PgAdminModule(Blueprint):
res.update(module.messages)
return res
@property
def javascripts(self):
javascripts = self.get_own_javascripts()
for module in self.submodules:
javascripts.extend(module.javascripts)
return javascripts
@property
def menu_items(self):
menu_items = self.get_own_menuitems()

17
web/pgadmin/utils/driver/registry.py
View File

@ -12,6 +12,21 @@ from abc import ABCMeta
from pgadmin.utils.dynamic_registry import create_registry_metaclass
@classmethod
def load_modules(cls, app=None):
submodules = []
from . import psycopg2 as module
submodules.append(module)
from . import abstract as module
submodules.append(module)
for module in submodules:
if "init_app" in module.__dict__.keys():
module.__dict__["init_app"](app)
DriverRegistry = create_registry_metaclass(
"DriverRegistry", __package__, decorate_as_module=True
"DriverRegistry", __package__, load_modules=load_modules,
decorate_as_module=True
)

5
web/pgadmin/utils/dynamic_registry/__init__.py
View File

@ -80,7 +80,8 @@ def __get_class_name(self, name, kwargs):
return name
def create_registry_metaclass(name, package, decorate_as_module=True):
def create_registry_metaclass(name, package, load_modules=__load_modules,
decorate_as_module=True):
class_params = {
# constructor
@ -93,7 +94,7 @@ def create_registry_metaclass(name, package, decorate_as_module=True):
# Member functions
"get": __get,
"load_modules": __load_modules,
"load_modules": load_modules,
"_name_": name,
"_decorate_cls_name": __get_module_name
if decorate_as_module is True else __get_class_name,