def main() -> None:
parser = argparse.ArgumentParser(
description="Create and populate the database tables.")
fill_arguments(parser)
options = parser.parse_args()
settings = get_appsettings(options)
with transaction.manager:
session = get_session(settings, transaction.manager)
from c2cgeoportal_commons.models.main import ( # pylint: disable=import-outside-toplevel
Interface, LayerGroup, LayerWMS, OGCServer, Theme,
)
interfaces = session.query(Interface).all()
ogc_server = session.query(OGCServer).filter(
OGCServer.name == "source for image/png").one()
layer_borders = LayerWMS("Borders", "borders")
layer_borders.interfaces = interfaces
layer_borders.ogc_server = ogc_server
layer_density = LayerWMS("Density", "density")
layer_density.interfaces = interfaces
layer_density.ogc_server = ogc_server
group = LayerGroup("Demo")
group.children = [layer_borders, layer_density]
theme = Theme("Demo")
theme.children = [group]
theme.interfaces = interfaces
session.add(theme)
print("Successfully added the demo theme")
def get_argparser() -> argparse.ArgumentParser:
"""Get the argument parser for this script."""
usage = """Usage: %prog [options] USERNAME
Reset a user password.
The username is used as password if the password is not provided with the corresponding option.
User can be created if it does not exist yet."""
parser = argparse.ArgumentParser(description=usage)
fill_arguments(parser)
parser.add_argument(
"--password",
"-p",
help="Set password (if not set, username is used as password")
parser.add_argument("--create",
"-c",
action="store_true",
default=False,
help="Create user if it does not already exist")
parser.add_argument("--rolename",
"-r",
default="role_admin",
help="The role name which must exist in the database")
parser.add_argument("--email", "-e", default=None, help="The user email")
parser.add_argument("user", help="The user")
return parser
def main():
parser = ArgumentParser(
prog=sys.argv[0],
add_help=True,
description=
"Tool used to migrate your old layers from the old structure to the new one.",
)
fill_arguments(parser)
parser.add_argument("--no-layers",
dest="layers",
action="store_false",
help="do not import the layers")
parser.add_argument("--no-groups",
dest="groups",
action="store_false",
help="do not import the groups")
parser.add_argument("--no-themes",
dest="themes",
action="store_false",
help="do not import the themes")
options = parser.parse_args()
settings = get_appsettings(options)
with transaction.manager:
session = get_session(settings, transaction.manager)
# Must be done only once we have loaded the project config
from c2cgeoportal_commons.models.main import (OGCServer, Theme,
LayerWMS, LayerWMTS,
LayerV1, LayerGroup)
if options.layers:
table_list = [LayerWMTS, LayerWMS, OGCServer]
for table in table_list:
print(("Emptying table {0!s}.".format(table.__table__)))
# Must be done exactly this way otherwise the cascade config in the
# models are not used
for t in session.query(table).all():
session.delete(t)
# List and create all distinct ogc_server
ogc_server(session, settings)
print("Converting layerv1.")
for layer in session.query(LayerV1).all():
layer_v1tov2(session, layer)
if options.groups:
print("Converting layer groups.")
for group in session.query(LayerGroup).all():
layergroup_v1tov2(session, group)
if options.themes:
print("Converting themes.")
for theme in session.query(Theme).all():
theme_v1tov2(session, theme)
def get_argparser() -> argparse.ArgumentParser:
"""Get the argument parser for this script."""
parser = argparse.ArgumentParser(description="Generate an auth token")
fill_arguments(parser)
parser.add_argument("user", help="The username")
parser.add_argument("password", help="The password")
parser.add_argument("valid",
type=int,
default=1,
nargs="?",
help="Is valid for, in days")
return parser
def main() -> None:
parser = ArgumentParser(
prog=sys.argv[0],
add_help=True,
description="Tool to fill the tsearch table (full-text search) from the theme information.",
)
parser.add_argument(
"--locale-folder",
default=LOCALE_PATH,
help="The folder where the locale files are stored (default to {})".format(LOCALE_PATH),
)
parser.add_argument("--interfaces", action="append", help="the interfaces to export")
parser.add_argument(
"--exclude-interfaces",
action="append",
default=["api"],
help="the interfaces to exclude (can't be used with --interfaces)",
)
parser.add_argument(
"--duplicate-name",
action="store_true",
dest="name",
help="allows to add a name more than one time,\n"
"by default if we find more than one element with the same name "
"only one will be imported",
)
parser.add_argument("--no-themes", action="store_false", dest="themes", help="do not import the themes")
parser.add_argument(
"--no-blocks",
action="store_false",
dest="blocks",
help="do not import the blocks (first level layer groups)",
)
parser.add_argument(
"--no-folders", action="store_false", dest="folders", help="do not import the folders (tree folders)"
)
parser.add_argument(
"--no-layers", action="store_false", dest="layers", help="do not import the layers (tree leaf)"
)
parser.add_argument("--package", help="the application package")
fill_arguments(parser)
options = parser.parse_args()
settings = get_appsettings(options)
with transaction.manager:
session = get_session(settings, transaction.manager)
Import(session, settings, options)
def main() -> None:
parser = argparse.ArgumentParser(description="Generate an auth token")
fill_arguments(parser)
parser.add_argument("user", help="The username")
parser.add_argument("password", help="The password")
parser.add_argument("valid",
type=int,
default=1,
nargs="?",
help="Is valid for, in days")
args = parser.parse_args()
settings = get_appsettings(args)
urllogin = settings.get("urllogin", {})
aeskey = urllogin.get("aes_key")
auth_enc = create_token(aeskey, args.user, args.password, args.valid)
print(("Use: auth={}".format(auth_enc)))
def main():
parser = argparse.ArgumentParser(
description=
"This script will rename all the theme elements to removes duplicated elements."
)
fill_arguments(parser)
options = parser.parse_args()
settings = get_appsettings(options)
with transaction.manager:
session = get_session(settings, transaction.manager)
from c2cgeoportal_commons.models.main import LayerV1, LayerWMS, LayerWMTS, LayerGroup, Theme
for class_ in [LayerV1, LayerWMS, LayerWMTS, LayerGroup, Theme]:
names = []
for item in session.query(class_).all():
if item.name in names:
i = 2
while "{}-{}".format(item.name, i) in names:
i += 1
item.name = "{}-{}".format(item.name, i)
names.append(item.name)
def _main():
"""
Emergency user create and password reset script
example, reset toto password to foobar:
docker-compose exec geoportal manage_users --password=foobar toto
example, create user foo with password bar and role admin:
docker-compose exec geoportal manage_users --create --rolename=role_admin --password=bar foo
to get the options list, do:
docker-compose exec geoportal manage_users --help
"""
usage = """Usage: %prog [options] USERNAME
Reset a user password.
The username is used as password if the password is not provided with the corresponding option.
User can be created if it does not exist yet."""
parser = argparse.ArgumentParser(description=usage)
fill_arguments(parser)
parser.add_argument("--password", "-p", help="Set password (if not set, username is used as password")
parser.add_argument(
"--create", "-c", action="store_true", default=False, help="Create user if it does not already exist"
)
parser.add_argument(
"--rolename", "-r", default="role_admin", help="The role name which must exist in the database"
)
parser.add_argument("--email", "-e", default=None, help="The user email")
parser.add_argument("user", help="The user")
options = parser.parse_args()
username = options.user
settings = get_appsettings(options)
with transaction.manager:
sess = get_session(settings, transaction.manager)
# Must be done only once we have loaded the project config
from c2cgeoportal_commons.models import main, static # pylint: disable=import-outside-toplevel
print("\n")
# Check that user exists
query = sess.query(static.User).filter_by(username=username)
result = query.count()
if result == 0:
if not options.create:
# If doesn't exist and no -c option, throw error
print("User {} does not exist in database".format(username))
sys.exit(1)
else:
if options.password is None:
parser.error("The password is mandatory on user creation")
if options.email is None:
parser.error("The email is mandatory on user creation")
# Get roles
query_role = sess.query(main.Role).filter(main.Role.name == options.rolename)
if query_role.count() == 0:
# Role not found in db?
print("Role matching {} does not exist in database".format(options.rolename))
sys.exit(1)
role = query_role.first()
user = static.User(
username=username,
password=options.password,
email=options.email,
settings_role=role,
roles=[role],
)
sess.add(user)
print(
(
"User {} created with password {} and role {}".format(
username, options.password, options.rolename
)
)
)
else:
# If user exists (assuming username are unique)
user = query.first()
if options.password is not None:
print("Password set to: {}".format(options.password))
user.password = "******".format(options.password)
if options.email is not None:
user.email = options.email
sess.add(user)
print("Password reset for user {}".format(username))
def main():
parser = ArgumentParser(
prog=sys.argv[0],
add_help=True,
description=
"Tool to fill the tsearch table (full-text search) from the theme information.",
)
locale_path_1 = os.path.join("{package}_geoportal", "locale", "")
locale_path_2 = os.path.join("geoportal", locale_path_1)
locale_path = locale_path_2 if os.path.exists(
"geoportal") else locale_path_1
parser.add_argument(
"--locale-folder",
default=locale_path,
help="The folder where the locale files are stored",
)
parser.add_argument(
"--interfaces",
nargs='+',
help="the interfaces to export",
)
parser.add_argument(
"--duplicate-name",
action="store_true",
dest="name",
help="allows to add a name more than one time,\n"
"by default if we find more than one element with the same name "
"only one will be imported",
)
parser.add_argument(
"--no-themes",
action="store_false",
dest="themes",
help="do not import the themes",
)
parser.add_argument(
"--no-blocks",
action="store_false",
dest="blocks",
help="do not import the blocks (first level layer groups)",
)
parser.add_argument(
"--no-folders",
action="store_false",
dest="folders",
help="do not import the folders (tree folders)",
)
parser.add_argument(
"--no-layers",
action="store_false",
dest="layers",
help="do not import the layers (tree leaf)",
)
parser.add_argument(
"--package",
help="the application package",
)
fill_arguments(parser)
options = parser.parse_args()
settings = get_appsettings(options)
with transaction.manager:
session = get_session(settings, transaction.manager)
Import(session, settings, options)
