def create_module_config(module_name, mod_path=None, build=True):
"""
Create the frontend config
"""
if not mod_path:
mod_path = str(GN_EXTERNAL_MODULE / module_name)
manifest_path = os.path.join(mod_path, 'manifest.toml')
# Create the frontend config for a module and rebuild if build=True
conf_manifest = utilstoml.load_and_validate_toml(manifest_path,
ManifestSchemaProdConf)
# import du module dans le sys.path
module_parent_dir = str(Path(mod_path).parent)
module_schema_conf = "{}.config.conf_schema_toml".format(
Path(mod_path).name) # noqa
sys.path.insert(0, module_parent_dir)
module = __import__(module_schema_conf, globals=globals())
front_module_conf_file = os.path.join(mod_path,
'config/conf_gn_module.toml') # noqa
config_module = utilstoml.load_and_validate_toml(
front_module_conf_file,
module.config.conf_schema_toml.GnModuleSchemaConf)
frontend_config_path = os.path.join(
mod_path, 'frontend/app/module.config.ts') # noqa
try:
with open(str(ROOT_DIR / frontend_config_path), 'w') as outputfile:
outputfile.write("export const ModuleConfig = ")
json.dump(config_module, outputfile, indent=True, sort_keys=True)
except FileNotFoundError:
log.info('No frontend config file')
if build:
build_geonature_front()
def generate_frontend_config(build):
"""
Génération des fichiers de configurations pour javascript
Relance le build du front par defaut
"""
create_frontend_config()
if build:
build_geonature_front()
log.info("Config successfully updated")
def install_packaged_gn_module(module_path, module_code, build):
# install python package and dependencies
subprocess.run(f"pip install -e {module_path}", shell=True, check=True)
# load python package
module_dist = get_dist_from_code(module_code)
if not module_dist:
raise ClickException(f"Unable to load module with code {module_code}")
# add module to database
try:
module_picto = load_entry_point(module_dist, 'gn_module', 'picto')
except ImportError:
module_picto = "fa-puzzle-piece"
module_object = TModules.query.filter_by(module_code=module_code).one()
if not module_object:
module_object = TModules(
module_code=module_code,
module_label=module_code.lower(),
module_path=module_code.lower(),
module_target="_self",
module_picto=module_picto,
active_frontend=True,
active_backend=True,
)
db.session.add(module_object)
else:
module_object.module_picto = module_picto
db.session.merge(module_object)
db.session.commit()
db_upgrade(revision=module_code.lower())
# symlink module in exernal module directory
module_symlink = GN_EXTERNAL_MODULE / module_code.lower()
if os.path.exists(module_symlink):
target = os.readlink(module_symlink)
if os.path.abspath(module_path) != target:
raise ClickException(f"Module symlink has wrong target '{target}'")
else:
os.symlink(os.path.abspath(module_path), module_symlink)
### Frontend
# creation du lien symbolique des assets externes
enable_frontend = create_external_assets_symlink(module_path,
module_code.lower())
install_frontend_dependencies(module_path)
# generation du fichier tsconfig.app.json
tsconfig_app_templating(app=current_app)
# generation du routing du frontend
frontend_routes_templating(app=current_app)
# generation du fichier de configuration du frontend
create_module_config(current_app, module_code, build=False)
if build:
# Rebuild the frontend
build_geonature_front(rebuild_sass=True)
def generate_frontend_config(conf_file, build):
"""
Génération des fichiers de configurations pour javascript
Relance le build du front par defaut
"""
try:
create_frontend_config(conf_file)
if build:
build_geonature_front()
log.info("Config successfully updated")
except FileNotFoundError:
log.warning("file {} doesn't exists".format(conf_file))
def generate_frontend_config(conf_file, build):
"""
Génération des fichiers de configurations pour javascript
Relance le build du front par defaut
"""
try:
create_frontend_config(conf_file)
if build:
build_geonature_front()
log.info('Config successfully updated')
except FileNotFoundError:
log.warning("file {} doesn't exists".format(conf_file))
def create_module_config(app, module_code, mod_path=None, build=True):
"""
Create the frontend config
"""
from geonature.core.gn_commons.models import TModules
with app.app_context():
if not mod_path:
# get the symlink location to write the config file
mod_path = os.readlink(
str(GN_EXTERNAL_MODULE / module_code.lower()))
# fetch the module in the DB from its name
module_object = (
DB.session.query(TModules)
.filter(TModules.module_code == module_code.upper())
.one()
)
# import du module dans le sys.path
module_parent_dir = str(Path(mod_path).parent)
module_schema_conf = "{}.config.conf_schema_toml".format(
Path(mod_path).name
) # noqa
sys.path.insert(0, module_parent_dir)
module = __import__(module_schema_conf, globals=globals())
front_module_conf_file = os.path.join(
mod_path, "config/conf_gn_module.toml"
) # noqa
config_module = utilstoml.load_and_validate_toml(
front_module_conf_file, module.config.conf_schema_toml.GnModuleSchemaConf
)
# set id_module and module_code
config_module["ID_MODULE"] = module_object.id_module
config_module["MODULE_CODE"] = module_object.module_code
config_module["MODULE_URL"] = module_object.module_path.replace(
" ", "")
frontend_config_path = os.path.join(
mod_path, "frontend/app/module.config.ts"
) # noqa
try:
with open(str(ROOT_DIR / frontend_config_path), "w") as outputfile:
outputfile.write("export const ModuleConfig = ")
json.dump(config_module, outputfile,
indent=True, sort_keys=True)
except FileNotFoundError:
log.info("No frontend config file")
if build:
build_geonature_front()
def create_module_config(app, module_code, mod_path=None, build=True):
"""
Create the frontend config
"""
from geonature.core.gn_commons.models import TModules
with app.app_context():
if not mod_path:
mod_path = str(GN_EXTERNAL_MODULE / module_code.lower())
# fetch the module in the DB from its name
module_object = (
DB.session.query(TModules)
.filter(TModules.module_code == module_code.upper())
.one()
)
# import du module dans le sys.path
module_parent_dir = str(Path(mod_path).parent)
module_schema_conf = "{}.config.conf_schema_toml".format(
Path(mod_path).name
) # noqa
sys.path.insert(0, module_parent_dir)
module = __import__(module_schema_conf, globals=globals())
front_module_conf_file = os.path.join(
mod_path, "config/conf_gn_module.toml"
) # noqa
config_module = utilstoml.load_and_validate_toml(
front_module_conf_file, module.config.conf_schema_toml.GnModuleSchemaConf
)
# set id_module and module_code
config_module["ID_MODULE"] = module_object.id_module
config_module["MODULE_CODE"] = module_object.module_code
config_module["MODULE_URL"] = module_object.module_path.replace(" ", "")
frontend_config_path = os.path.join(
mod_path, "frontend/app/module.config.ts"
) # noqa
try:
with open(str(ROOT_DIR / frontend_config_path), "w") as outputfile:
outputfile.write("export const ModuleConfig = ")
json.dump(config_module, outputfile, indent=True, sort_keys=True)
except FileNotFoundError:
log.info("No frontend config file")
if build:
build_geonature_front()
def create_module_config(app, module_code, build=True):
"""
Create the frontend config
"""
module_code = module_code.upper()
try:
module_object = TModules.query.filter_by(module_code=module_code).one()
except NoResultFound:
raise Exception(f"Module with code '{module_code}' not found in database.")
_, module_config, _ = import_gn_module(module_object)
frontend_config_path = os.path.join(module_config['FRONTEND_PATH'], "app/module.config.ts")
try:
with open(str(ROOT_DIR / frontend_config_path), "w") as outputfile:
outputfile.write("export const ModuleConfig = ")
json.dump(module_config, outputfile, indent=True, sort_keys=True)
except FileNotFoundError:
log.info("No frontend config file")
raise
if build:
build_geonature_front()
def create_module_config(app, module_code, mod_path=None, build=True):
"""
Create the frontend config
"""
with app.app_context():
# fetch the module in the DB from its name
module_object = (DB.session.query(TModules).filter(
TModules.module_code == module_code.upper()).one())
module, blueprint = import_gn_module(module_object)
frontend_config_path = os.path.join(blueprint.config['FRONTEND_PATH'],
"app/module.config.ts") # noqa
try:
with open(str(ROOT_DIR / frontend_config_path), "w") as outputfile:
outputfile.write("export const ModuleConfig = ")
json.dump(blueprint.config,
outputfile,
indent=True,
sort_keys=True)
except FileNotFoundError:
log.info("No frontend config file")
if build:
build_geonature_front()
def install_gn_module(module_path, url, conf_file, build, enable_backend):
"""
Installation d'un module gn
"""
try:
# Vérification que le chemin module path soit correct
if not Path(module_path).is_dir():
raise GeoNatureError("dir {} doesn't exists".format(module_path))
# TODO vérifier que l'utilisateur est root ou du groupe geonature
app = get_app_for_cmd(conf_file, with_external_mods=False)
with app.app_context():
from geonature.core.gn_commons.models import TModules
sys.path.append(module_path)
# Vérification de la conformité du module
# Vérification de la présence de certain fichiers
check_gn_module_file(module_path)
# Vérification de la version de geonature par rapport au manifest
module_code = None
module_code = check_manifest(module_path)
try:
# Vérification que le module n'est pas déjà activé
mod = (DB.session.query(TModules).filter(
TModules.module_code == module_code).one())
except NoResultFound:
# Si le module n'est pas déjà dans la table gn_commons.t_modules, on l'installe
# sinon on leve une execption et on arrête la commande
# Vérification de la conformité du code :
# installation
# front end
# backend
check_codefile_validity(module_path, module_code)
# Installation du module
run_install_gn_module(app, module_path)
# copie dans external mods:
copy_in_external_mods(module_path, module_code.lower())
# creation du lien symbolique des assets externes
enable_frontend = create_external_assets_symlink(
module_path, module_code.lower())
# ajout du module dans la table gn_commons.t_modules
add_application_db(app, module_code, url, enable_frontend,
enable_backend)
# Enregistrement de la config du module
gn_module_register_config(module_code.lower())
if enable_frontend:
# generation du du routing du frontend
frontend_routes_templating(app)
# generation du fichier de configuration du frontend
create_module_config(app,
module_code.lower(),
module_path,
build=False)
if build and enable_frontend:
# Rebuild the frontend
build_geonature_front(rebuild_sass=True)
# finally restart geonature backend via supervisor
subprocess.call(
["sudo", "supervisorctl", "restart", "geonature2"])
else:
raise GeoNatureError(
"The module {} is already installed, but maybe not activated"
.format(module_code)) # noqa
except (GNModuleInstallError, GeoNatureError) as ex:
log.critical((
"\n\n\033[91mError while installing GN module '{}'\033[0m.The process returned:\n\t{}"
).format(module_code, ex))
sys.exit(1)
def install_gn_module(module_path, url, conf_file, build):
"""
Installation d'un module gn
"""
try:
# Vérification que le chemin module path soit correct
if not Path(module_path).is_dir():
raise GeoNatureError("dir {} doesn't exists".format(module_path))
# TODO vérifier que l'utilisateur est root ou du groupe geonature
app = get_app_for_cmd(conf_file, with_external_mods=False)
with app.app_context():
from geonature.core.gn_commons.models import TModules
sys.path.append(module_path)
# Vérification de la conformité du module
# Vérification de la présence de certain fichiers
check_gn_module_file(module_path)
# Vérification de la version de geonature par rapport au manifest
module_code = None
module_code = check_manifest(module_path)
try:
# Vérification que le module n'est pas déjà activé
mod = (
DB.session.query(TModules)
.filter(TModules.module_code == module_code)
.one()
)
except NoResultFound:
# Si le module n'est pas déjà dans la table gn_commons.t_modules, on l'installe
# sinon on leve une execption et on arrête la commande
# Vérification de la conformité du code :
# installation
# front end
# backend
check_codefile_validity(module_path, module_code)
# Installation du module
run_install_gn_module(app, module_path)
# copie dans external mods:
copy_in_external_mods(module_path, module_code.lower())
# creation du lien symbolique des assets externes
enable_frontend = create_external_assets_symlink(
module_path, module_code.lower()
)
# ajout du module dans la table gn_commons.t_modules
add_application_db(app, module_code, url, enable_frontend)
# Enregistrement de la config du module
gn_module_register_config(module_code.lower())
if enable_frontend:
# generation du du routing du frontend
frontend_routes_templating(app)
# generation du fichier de configuration du frontend
create_module_config(
app, module_code.lower(), module_path, build=False
)
if build and enable_frontend:
# Rebuild the frontend
build_geonature_front(rebuild_sass=True)
# finally restart geonature backend via supervisor
subprocess.call(["sudo", "supervisorctl", "restart", "geonature2"])
else:
raise GeoNatureError(
"The module {} is already installed, but maybe not activated".format(
module_code
)
) # noqa
except (GNModuleInstallError, GeoNatureError) as ex:
log.critical(
(
"\n\n\033[91mError while installing GN module '{}'\033[0m.The process returned:\n\t{}"
).format(module_code, ex)
)
sys.exit(1)
def frontend_build(build_sass):
"""
Lance le build du frontend
"""
build_geonature_front(build_sass)
def install_gn_module(module_path, url, conf_file, build, enable_backend):
"""
Installation d'un module gn
"""
try:
# Indique si l'utilisateur est en train de
# réaliser une installation du module
# et non pas une mise à jour
# Permet qu'en cas d'erreur à l'installation de supprimer
# les traces d'installation de ce module
fresh_install = False
# Vérification que le chemin module path soit correct
if not Path(module_path).is_dir():
raise GeoNatureError("dir {} doesn't exists".format(module_path))
# TODO vérifier que l'utilisateur est root ou du groupe geonature
app = create_app(with_external_mods=False)
with app.app_context():
sys.path.append(module_path)
# Vérification de la conformité du module
# Vérification de la présence de certain fichiers
check_gn_module_file(module_path)
# Vérification de la version de geonature par rapport au manifest
module_code = None
module_code = check_manifest(module_path)
try:
# Vérification que le module n'est pas déjà activé
DB.session.query(TModules).filter(
TModules.module_code == module_code).one()
except NoResultFound:
try:
# Si le module n'est pas déjà dans la table gn_commons.t_modules, on l'installe
# sinon on leve une execption et on arrête la commande
# Installation des dépendances python
gn_module_import_requirements(module_path)
# Vérification de la conformité du code :
# installation
# front end
# backend
check_codefile_validity(module_path, module_code)
# copie dans external mods:
copy_in_external_mods(module_path, module_code.lower())
# creation du lien symbolique des assets externes
enable_frontend = create_external_assets_symlink(
module_path, module_code.lower())
# ajout du module dans la table gn_commons.t_modules
fresh_install = add_application_db(app, module_code, url,
enable_frontend,
enable_backend)
# Installation du module
run_install_gn_module(app, module_path)
# Enregistrement de la config du module
gn_module_register_config(module_code)
if enable_frontend:
install_frontend_dependencies(module_path)
# generation du fichier tsconfig.app.json
tsconfig_app_templating(app=app)
# generation du routing du frontend
frontend_routes_templating(app=app)
# generation du fichier de configuration du frontend
create_module_config(app, module_code, build=False)
if build and enable_frontend:
# Rebuild the frontend
build_geonature_front(rebuild_sass=True)
# finally restart geonature backend via supervisor
subprocess.call(
["sudo", "supervisorctl", "restart", "geonature2"])
except Exception as e:
log.error("%s", e)
raise GeoNatureError(
"Error during module {} installation".format(
module_code)) # noqa
else:
raise GeoNatureError(
"The module {} is already installed, but maybe not activated"
.format(module_code)) # noqa
except (GNModuleInstallError, GeoNatureError) as ex:
log.critical((
"\n\n\033[91mError while installing GN module \033[0m.The process returned:\n\t{}"
).format(ex))
# S'il y a une erreur lors de l'installation initiale du module
# suppression de ce module
if fresh_install:
remove_application_db(app, module_code)
sys.exit(1)
def install_packaged_gn_module(module_path, module_code, build):
# install python package and dependencies
subprocess.run(f"pip install -e '{module_path}'", shell=True, check=True)
# refresh list of entry points
importlib.reload(site)
for entry in sys.path:
pkg_resources.working_set.add_entry(entry)
# load python package
module_dist = get_dist_from_code(module_code)
if not module_dist:
raise ClickException(f"Unable to load module with code {module_code}")
# add module to database
try:
module_picto = load_entry_point(module_dist, 'gn_module', 'picto')
except ImportError:
module_picto = "fa-puzzle-piece"
try:
module_object = TModules.query.filter_by(module_code=module_code).one()
module_object.module_picto = module_picto
db.session.merge(module_object)
except sa_exc.NoResultFound:
module_object = TModules(
module_code=module_code,
module_label=module_code.lower(),
module_path=module_code.lower(),
module_target="_self",
module_picto=module_picto,
active_frontend=True,
active_backend=True,
)
db.session.add(module_object)
db.session.commit()
info = get_entry_info(module_dist, 'gn_module', 'migrations')
if info is not None:
try:
alembic_branch = load_entry_point(module_dist, 'gn_module',
'alembic_branch')
except ImportError:
alembic_branch = module_code.lower()
db_upgrade(revision=alembic_branch + '@head')
else:
log.info(
"Module do not provide any migration files, skipping database upgrade."
)
# symlink module in exernal module directory
module_symlink = GN_EXTERNAL_MODULE / module_code.lower()
if os.path.exists(module_symlink):
target = os.readlink(module_symlink)
if os.path.realpath(module_path) != os.path.realpath(target):
raise ClickException(
f"Module symlink has wrong target: '{target}'")
else:
os.symlink(os.path.abspath(module_path), module_symlink)
# creation du fichier conf_gn_module.toml
gn_module_register_config(module_code)
### Frontend
# creation du lien symbolique des assets externes
enable_frontend = create_external_assets_symlink(module_path,
module_code.lower())
install_frontend_dependencies(module_path)
# generation du fichier tsconfig.app.json
tsconfig_app_templating(app=current_app)
# generation du routing du frontend
frontend_routes_templating(app=current_app)
# generation du fichier de configuration du frontend
create_module_config(current_app, module_code, build=False)
if build:
# Rebuild the frontend
build_geonature_front(rebuild_sass=True)
def frontend_build(build_sass):
"""
Lance le build du frontend
"""
build_geonature_front(build_sass)
