def main():
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 Interface, OGCServer, Theme, LayerGroup, LayerWMS
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 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 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-run manage_users --password=foobar toto
example, create user foo with password bar and role admin:
./docker-compose-run manage_users --create --rolename=role_admin --password=bar foo
to get the options list, do:
./docker-compose-run 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
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))
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))
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)