def __init__(self, server_iface: qgis.server.QgsServerInterface):
super().__init__(server_iface)
self.server_iface = server_iface
self.initialized = False
try:
config.init(
os.environ.get("GEOMAPFISH_CONFIG",
"/etc/qgisserver/geomapfish.yaml"))
c2cwsgiutils.broadcast.init()
DBSession = create_session_factory( # noqa: ignore=N806
config.get("sqlalchemy_slave.url"),
config.get_config().get("sqlalchemy", {}))
if "GEOMAPFISH_OGCSERVER" in os.environ:
self.single = True
self.ogcserver_accesscontrol = OGCServerAccessControl(
server_iface,
os.environ["GEOMAPFISH_OGCSERVER"],
os.environ["QGIS_PROJECT_FILE"],
config.get("srid"),
DBSession,
)
LOG.info("Use OGC server named '%s'.",
os.environ["GEOMAPFISH_OGCSERVER"])
self.initialized = True
elif "GEOMAPFISH_ACCESSCONTROL_CONFIG" in os.environ:
self.single = False
self.ogcserver_accesscontrols = {}
with open(os.environ["GEOMAPFISH_ACCESSCONTROL_CONFIG"]
) as ac_config_file:
ac_config = yaml.safe_load(ac_config_file.read())
for map_, map_config in ac_config.get("map_config").items():
map_config["access_control"] = OGCServerAccessControl(
server_iface, map_config["ogc_server"], map_,
config.get("srid"), DBSession)
self.ogcserver_accesscontrols[map_] = map_config
LOG.info("Use config '%s'.",
os.environ["GEOMAPFISH_ACCESSCONTROL_CONFIG"])
self.initialized = True
else:
LOG.error(
"The environment variable 'GEOMAPFISH_OGCSERVER' or "
"'GEOMAPFISH_ACCESSCONTROL_CONFIG' is not defined.", )
except Exception: # pylint: disable=broad-except
LOG.error("Cannot setup GeoMapFishAccessControl", exc_info=True)
server_iface.registerAccessControl(
self, int(os.environ.get("GEOMAPFISH_POSITION", 100)))
def __init__(self, server_iface):
super().__init__(server_iface)
self.server_iface = server_iface
try:
config.init(
os.environ.get('GEOMAPFISH_CONFIG',
'/etc/qgisserver/geomapfish.yaml'))
c2cwsgiutils.broadcast.init(None)
configure_mappers()
engine = sqlalchemy.create_engine(
config.get('sqlalchemy_slave.url'))
session_factory = sessionmaker()
session_factory.configure(bind=engine)
DBSession = scoped_session(session_factory) # noqa: N806
if "GEOMAPFISH_OGCSERVER" in os.environ:
self.single = True
self.ogcserver_accesscontrol = OGCServerAccessControl(
server_iface, os.environ['GEOMAPFISH_OGCSERVER'],
config.get('srid'), DBSession)
QgsMessageLog.logMessage("Use OGC server named '{}'.".format(
os.environ["GEOMAPFISH_OGCSERVER"]))
elif "GEOMAPFISH_ACCESSCONTROL_CONFIG" in os.environ:
self.single = False
self.ogcserver_accesscontrols = {}
with open(os.environ["GEOMAPFISH_ACCESSCONTROL_CONFIG"]
) as ac_config_file:
ac_config = yaml.safe_load(ac_config_file.read())
for map_, map_config in ac_config.get("map_config").items():
map_config["access_control"] = OGCServerAccessControl(
server_iface, map_config["ogc_server"],
config.get('srid'), DBSession)
self.ogcserver_accesscontrols[map_] = map_config
QgsMessageLog.logMessage("Use config '{}'.".format(
os.environ["GEOMAPFISH_ACCESSCONTROL_CONFIG"]))
else:
raise GMFException(
"The environment variable 'GEOMAPFISH_OGCSERVER' or "
"'GEOMAPFISH_ACCESSCONTROL_CONFIG' is not defined.")
except Exception:
QgsMessageLog.logMessage(''.join(
traceback.format_exception(*sys.exc_info())))
raise
server_iface.registerAccessControl(
self, int(os.environ.get("GEOMAPFISH_POSITION", 100)))
def _collect_print_config(config, filename):
result = []
for template_ in list(config.get("templates").keys()):
result.append(
Message(None, template_, None, [], "", "",
(filename, "template/{}".format(template_))))
result += [
Message(
None, attribute, None, [], "", "",
(filename, "template/{}/{}".format(template_, attribute)))
for attribute in list(
config.get("templates")[template_].attributes.keys())
]
return result
def downgrade():
schema = config['schema']
staticschema = config.get('schema_static')
parentschema = config.get('parentschema')
op.create_table(
'user',
Column('type', String(10), nullable=False),
Column('id', Integer, primary_key=True),
Column('username', Unicode, unique=True, nullable=False),
Column('password', Unicode, nullable=False),
Column('email', Unicode, nullable=False),
Column('is_password_changed', Boolean, default=False),
Column('role_id', Integer, ForeignKey(schema + '.role.id'), nullable=False),
schema=schema,
)
parent_column = ''
parent_select = ''
parent_join = ''
if parentschema is not None and parentschema is not '': # pragma: no cover
op.add_column(
'user',
Column('parent_role_id', Integer, ForeignKey(parentschema + '.role.id')),
schema=schema
)
parent_column = ', parent_role_id'
parent_select = ', pr.id'
parent_join = (
'LEFT OUTER JOIN {parentschema}.role AS pr ON (pr.name = u.parent_role_name)'.format(
parentschema=parentschema,
)
)
op.execute(
'INSERT INTO %(schema)s.user '
'(type, username, password, email, is_password_changed, role_id%(parent_column)s) ('
'SELECT u.type, u.username, u.password, u.email, '
'u.is_password_changed, r.id%(parent_select)s '
'FROM %(staticschema)s.user AS u '
'LEFT OUTER JOIN %(schema)s.role AS r ON (r.name = u.role_name) %(parent_join)s'
')' % {
'staticschema': staticschema,
'schema': schema,
'parent_select': parent_select,
'parent_column': parent_column,
'parent_join': parent_join,
}
)
op.drop_table('user', schema=staticschema)
def downgrade() -> None:
"""Downgrade."""
schema = config["schema"]
staticschema = config.get("schema_static")
parentschema = config.get("parentschema")
op.create_table(
"user",
Column("type", String(10), nullable=False),
Column("id", Integer, primary_key=True),
Column("username", Unicode, unique=True, nullable=False),
Column("password", Unicode, nullable=False),
Column("email", Unicode, nullable=False),
Column("is_password_changed", Boolean, default=False),
Column("role_id",
Integer,
ForeignKey(schema + ".role.id"),
nullable=False),
schema=schema,
)
parent_column = ""
parent_select = ""
parent_join = ""
if parentschema is not None and parentschema != "":
op.add_column("user",
Column("parent_role_id", Integer,
ForeignKey(parentschema + ".role.id")),
schema=schema)
parent_column = ", parent_role_id"
parent_select = ", pr.id"
parent_join = "LEFT OUTER JOIN {parentschema}.role AS pr ON (pr.name = u.parent_role_name)".format(
parentschema=parentschema)
op.execute(
"INSERT INTO %(schema)s.user "
"(type, username, password, email, is_password_changed, role_id%(parent_column)s) ("
"SELECT u.type, u.username, u.password, u.email, "
"u.is_password_changed, r.id%(parent_select)s "
"FROM %(staticschema)s.user AS u "
"LEFT OUTER JOIN %(schema)s.role AS r ON (r.name = u.role_name) %(parent_join)s"
")" % {
"staticschema": staticschema,
"schema": schema,
"parent_select": parent_select,
"parent_column": parent_column,
"parent_join": parent_join,
})
op.drop_table("user", schema=staticschema)
def upgrade():
schema = config["schema"]
staticschema = config["schema_static"]
parentschema = config.get("parentschema")
engine = op.get_bind().engine
if type(engine).__name__ != "MockConnection" and op.get_context(
).dialect.has_table(engine, "user",
schema=staticschema): # pragma: no cover
return
op.create_table(
"user",
Column("type", String(10), nullable=False),
Column("id", Integer, primary_key=True),
Column("username", Unicode, unique=True, nullable=False),
Column("password", Unicode, nullable=False),
Column("email", Unicode, nullable=False),
Column("is_password_changed", Boolean, default=False),
Column("role_name", String),
schema=staticschema,
)
parent_column = ""
parent_select = ""
parent_join = ""
if parentschema is not None and parentschema != "": # pragma: no cover
op.add_column("user",
Column("parent_role_name", String),
schema=staticschema)
parent_column = ", parent_role_name"
parent_select = ", pr.name"
parent_join = "LEFT OUTER JOIN {parentschema!s}.role AS pr ON (pr.id = u.parent_role_id)".format(
parentschema=parentschema)
try:
op.execute(
"INSERT INTO %(staticschema)s.user "
"(type, username, password, email, is_password_changed, role_name%(parent_column)s) ("
"SELECT u.type, u.username, u.password, u.email, "
"u.is_password_changed, r.name%(parent_select)s "
"FROM %(schema)s.user AS u "
"LEFT OUTER JOIN %(schema)s.role AS r ON (r.id = u.role_id) %(parent_join)s"
")" % {
"staticschema": staticschema,
"schema": schema,
"parent_select": parent_select,
"parent_column": parent_column,
"parent_join": parent_join,
})
op.drop_table("user", schema=schema)
except Exception:
op.execute(
"INSERT INTO %(staticschema)s.user (type, username, email, password, role) "
"VALUES ( 'user', 'admin', '*****@*****.**', '%(pass)s', 'role_admin')"
% {
"staticschema": staticschema,
"pass": sha1("admin".encode("utf-8")).hexdigest()
})
def __init__(self, server_iface):
super().__init__(server_iface)
self.server_iface = server_iface
self.initialized = False
try:
config.init(
os.environ.get("GEOMAPFISH_CONFIG",
"/etc/qgisserver/geomapfish.yaml"))
c2cwsgiutils.broadcast.init()
configure_mappers()
db_match = re.match(".*(@[^@]+)$",
config.get("sqlalchemy_slave.url"))
QgsMessageLog.logMessage(
"Connect to the database: ***{}".format(
db_match.group(1) if db_match else ""),
"GeoMapFishAccessControl",
level=Qgis.Info,
)
engine = sqlalchemy.create_engine(
config["sqlalchemy_slave.url"],
**(config.get_config().get("sqlalchemy", {})))
session_factory = sessionmaker()
session_factory.configure(bind=engine)
DBSession = scoped_session(session_factory) # noqa: N806
if "GEOMAPFISH_OGCSERVER" in os.environ:
self.single = True
self.ogcserver_accesscontrol = OGCServerAccessControl(
server_iface, os.environ["GEOMAPFISH_OGCSERVER"],
config.get("srid"), DBSession)
QgsMessageLog.logMessage(
"Use OGC server named '{}'.".format(
os.environ["GEOMAPFISH_OGCSERVER"]),
"GeoMapFishAccessControl",
level=Qgis.Info,
)
self.initialized = True
elif "GEOMAPFISH_ACCESSCONTROL_CONFIG" in os.environ:
self.single = False
self.ogcserver_accesscontrols = {}
with open(os.environ["GEOMAPFISH_ACCESSCONTROL_CONFIG"]
) as ac_config_file:
ac_config = yaml.safe_load(ac_config_file.read())
for map_, map_config in ac_config.get("map_config").items():
map_config["access_control"] = OGCServerAccessControl(
server_iface, map_config["ogc_server"],
config.get("srid"), DBSession)
self.ogcserver_accesscontrols[map_] = map_config
QgsMessageLog.logMessage(
"Use config '{}'.".format(
os.environ["GEOMAPFISH_ACCESSCONTROL_CONFIG"]),
"GeoMapFishAccessControl",
level=Qgis.Info,
)
self.initialized = True
else:
QgsMessageLog.logMessage(
"The environment variable 'GEOMAPFISH_OGCSERVER' or "
"'GEOMAPFISH_ACCESSCONTROL_CONFIG' is not defined.",
"GeoMapFishAccessControl",
level=Qgis.Critical,
)
except Exception:
print("".join(traceback.format_exception(*sys.exc_info())))
QgsMessageLog.logMessage(
"".join(traceback.format_exception(*sys.exc_info())),
"GeoMapFishAccessControl",
level=Qgis.Critical,
)
server_iface.registerAccessControl(
self, int(os.environ.get("GEOMAPFISH_POSITION", 100)))
def __init__(self, server_iface: qgis.server.QgsServerInterface):
super().__init__(server_iface)
self.server_iface = server_iface
self.initialized = False
try:
config.init(
os.environ.get("GEOMAPFISH_CONFIG",
"/etc/qgisserver/geomapfish.yaml"))
c2cwsgiutils.broadcast.init()
DBSession = create_session_factory( # noqa: ignore=N806
config.get("sqlalchemy_slave.url"),
config.get_config().get("sqlalchemy", {}))
if "GEOMAPFISH_OGCSERVER" in os.environ:
self.single = True
self.ogcserver_accesscontrol = OGCServerAccessControl(
server_iface,
os.environ["GEOMAPFISH_OGCSERVER"],
os.environ["QGIS_PROJECT_FILE"],
config.get("srid"),
DBSession,
)
LOG.info("Use OGC server named '%s'.",
os.environ["GEOMAPFISH_OGCSERVER"])
self.initialized = True
elif "GEOMAPFISH_ACCESSCONTROL_CONFIG" in os.environ:
self.single = False
self.ogcserver_accesscontrols = {}
with open(os.environ["GEOMAPFISH_ACCESSCONTROL_CONFIG"],
encoding="utf-8") as ac_config_file:
ac_config = yaml.safe_load(ac_config_file.read())
for map_, map_config in ac_config.get("map_config").items():
map_config["access_control"] = OGCServerAccessControl(
server_iface, map_config["ogc_server"], map_,
config.get("srid"), DBSession)
self.ogcserver_accesscontrols[map_] = map_config
LOG.info("Use config '%s'.",
os.environ["GEOMAPFISH_ACCESSCONTROL_CONFIG"])
self.initialized = True
elif "GEOMAPFISH_ACCESSCONTROL_BASE_URL" in os.environ:
self.ogcserver_accesscontrols = {}
single_ogc_server = None
base_url = Url(os.environ["GEOMAPFISH_ACCESSCONTROL_BASE_URL"])
session = DBSession()
try:
from c2cgeoportal_commons.models.main import ( # pylint: disable=import-outside-toplevel
OGCServer, )
for ogcserver in session.query(OGCServer).all():
errors: Set[str] = set()
url = get_url2(
f"The OGC server '{ogcserver.name}'",
ogcserver.url,
None,
errors,
config.get_config().get("servers", {}),
)
if errors:
LOG.warning(
"Ignoring OGC server '%s', get error on parsing URL:\n%s",
ogcserver.name,
"\n".join(errors),
)
continue
if url is None:
LOG.warning(
"Ignoring OGC server '%s', the URL is None",
ogcserver.name)
continue
if (base_url.scheme == url.scheme
and base_url.netloc == url.netloc
and base_url.path == url.path):
query = url.query_lower
if "map" not in query:
if single_ogc_server is None:
single_ogc_server = ogcserver
LOG.debug(
"OGC server '%s', 'map' is not in the parameters => single server?",
ogcserver.name,
)
else:
LOG.error(
"OGC server '%s', 'map' is not in the parameters and we already have a single OCG server '%s'",
ogcserver.name,
single_ogc_server.name,
)
continue
map_ = url.query_lower["map"]
self.ogcserver_accesscontrols[map_] = {
"ogcserver":
ogcserver.name,
"access_control":
OGCServerAccessControl(
server_iface,
ogcserver.name,
map_,
config.get("srid"),
DBSession,
ogcserver=ogcserver,
),
}
LOG.info("OGC server '%s' registered for map",
ogcserver.name)
else:
LOG.debug(
"Ignoring OGC server '%s', Don't match the base URL '%s' and '%s'",
ogcserver.name,
base_url,
url,
)
if self.ogcserver_accesscontrols and single_ogc_server is not None:
if os.environ.get("QGIS_PROJECT_FILE"):
LOG.error(
"We have OGC servers with and without parameter MAP and a value in QGIS_PROJECT_FILE, fallback to single OGC server mode."
)
self.ogcserver_accesscontrols = {}
else:
LOG.error(
"We have OGC servers with and without parameter MAP but no value in QGIS_PROJECT_FILE, fallback to multiple OGC server mode."
)
single_ogc_server = None
if single_ogc_server is not None:
self.single = True
self.ogcserver_accesscontrol = OGCServerAccessControl(
server_iface,
single_ogc_server.name,
os.environ["QGIS_PROJECT_FILE"],
config.get("srid"),
DBSession,
single_ogc_server,
)
LOG.info("Use OGC server named '%s'.",
single_ogc_server.name)
else:
self.single = False
self.initialized = True
finally:
session.close()
else:
LOG.error(
"The environment variable 'GEOMAPFISH_OGCSERVER', 'GEOMAPFISH_ACCESSCONTROL_CONFIG' "
"or 'GEOMAPFISH_ACCESSCONTROL_BASE_URL' should be defined.",
)
except Exception: # pylint: disable=broad-except
LOG.error("Cannot setup GeoMapFishAccessControl", exc_info=True)
server_iface.registerAccessControl(
self, int(os.environ.get("GEOMAPFISH_POSITION", 100)))
def upgrade():
schema = config['schema']
schema_static = config['schema_static']
parentschema = config.get('parentschema')
srid = config.get('srid')
engine = op.get_bind().engine
if type(engine).__name__ != 'MockConnection' and \
op.get_context().dialect.has_table(
engine, 'functionality', schema=schema): # pragma: no cover
return
op.create_table(
'functionality',
Column('id', Integer, primary_key=True),
Column('name', Unicode, nullable=False),
Column('value', Unicode, nullable=False),
Column('description', Unicode),
schema=schema,
)
op.create_table(
'treeitem',
Column('type', String(10), nullable=False),
Column('id', Integer, primary_key=True),
Column('name', Unicode),
Column('order', Integer, nullable=False),
Column('metadataURL', Unicode),
schema=schema,
)
op.create_table(
'restrictionarea',
Column('id', Integer, primary_key=True),
Column('name', Unicode),
Column('description', Unicode),
Column('readwrite', Boolean, default=False),
schema=schema,
)
op.execute("SELECT AddGeometryColumn('%(schema)s', 'restrictionarea', "
"'area', %(srid)s, 'POLYGON', 2)" % {
'schema': schema,
'srid': srid
})
op.create_table(
'shorturl',
Column('id', Integer, primary_key=True),
Column('url', Unicode(1000)),
Column('ref', String(20), index=True, unique=True, nullable=False),
Column('creator_email', Unicode(200)),
Column('creation', DateTime),
Column('last_hit', DateTime),
Column('nb_hits', Integer),
schema=schema_static,
)
op.create_table(
'role',
Column('id', Integer, primary_key=True),
Column('name', Unicode, unique=True, nullable=False),
Column('description', Unicode),
schema=schema,
)
op.execute("SELECT AddGeometryColumn('%(schema)s', 'role', "
"'extent', %(srid)s, 'POLYGON', 2)" % {
'schema': schema,
'srid': srid
})
role = Table(
'role',
MetaData(),
Column('name', Unicode, unique=True, nullable=False),
schema=schema,
)
op.bulk_insert(role, [{'name': 'role_admin'}])
op.create_table(
'layer',
Column('id',
Integer,
ForeignKey(schema + '.treeitem.id'),
primary_key=True),
Column('public', Boolean, default=True),
Column('inMobileViewer', Boolean, default=True),
Column('inDesktopViewer', Boolean, default=True),
Column('isChecked', Boolean, default=True),
Column('icon', Unicode),
Column('layerType', Unicode(12)),
Column('url', Unicode),
Column('imageType', Unicode(10)),
Column('style', Unicode),
Column('dimensions', Unicode),
Column('matrixSet', Unicode),
Column('wmsUrl', Unicode),
Column('wmsLayers', Unicode),
Column('queryLayers', Unicode),
Column('kml', Unicode),
Column('isSingleTile', Boolean),
Column('legend', Boolean, default=True),
Column('legendImage', Unicode),
Column('legendRule', Unicode),
Column('isLegendExpanded', Boolean, default=False),
Column('minResolution', Float),
Column('maxResolution', Float),
Column('disclaimer', Unicode),
Column('identifierAttributeField', Unicode),
Column('geoTable', Unicode),
Column('excludeProperties', Unicode),
Column('timeMode', Unicode(8)),
schema=schema,
)
op.create_table(
'role_restrictionarea',
Column('role_id',
Integer,
ForeignKey(schema + '.role.id'),
primary_key=True),
Column('restrictionarea_id',
Integer,
ForeignKey(schema + '.restrictionarea.id'),
primary_key=True),
schema=schema,
)
op.create_table(
'tsearch',
Column('id', Integer, primary_key=True),
Column('label', Unicode),
Column('layer_name', Unicode),
Column('role_id',
Integer,
ForeignKey(schema + '.role.id'),
nullable=True),
Column('public', Boolean, server_default='true'),
Column('ts', TsVector),
Column('params', Unicode, nullable=True),
schema=schema,
)
op.execute("SELECT AddGeometryColumn('%(schema)s', 'tsearch', 'the_geom', "
"%(srid)s, 'GEOMETRY', 2)" % {
'schema': schema,
'srid': srid
})
op.create_index('tsearch_ts_idx',
'tsearch', ['ts'],
schema=schema,
postgresql_using='gin')
op.create_table(
'treegroup',
Column('id',
Integer,
ForeignKey(schema + '.treeitem.id'),
primary_key=True),
schema=schema,
)
op.create_table(
'user',
Column('type', String(10), nullable=False),
Column('id', Integer, primary_key=True),
Column('username', Unicode, unique=True, nullable=False),
Column('password', Unicode, nullable=False),
Column('email', Unicode, nullable=False),
Column('is_password_changed', Boolean, default=False),
Column('role_id',
Integer,
ForeignKey(schema + '.role.id'),
nullable=False),
schema=schema,
)
if parentschema is not None and parentschema is not '': # pragma: no cover
op.add_column('user',
Column('parent_role_id', Integer,
ForeignKey(parentschema + '.role.id')),
schema=schema)
op.execute(
"INSERT INTO %(schema)s.user (type, username, email, password, role_id) "
"(SELECT 'user', 'admin', '*****@*****.**', '%(pass)s', r.id "
"FROM %(schema)s.role AS r "
"WHERE r.name = 'role_admin')" % {
'schema': schema,
'pass': sha1('admin'.encode('utf-8')).hexdigest()
})
op.create_table(
'role_functionality',
Column('role_id',
Integer,
ForeignKey(schema + '.role.id'),
primary_key=True),
Column('functionality_id',
Integer,
ForeignKey(schema + '.functionality.id'),
primary_key=True),
schema=schema,
)
op.create_table(
'user_functionality',
Column('user_id',
Integer,
ForeignKey(schema + '.user.id'),
primary_key=True),
Column('functionality_id',
Integer,
ForeignKey(schema + '.functionality.id'),
primary_key=True),
schema=schema,
)
op.create_table(
'layergroup',
Column('id',
Integer,
ForeignKey(schema + '.treegroup.id'),
primary_key=True),
Column('isExpanded', Boolean),
Column('isInternalWMS', Boolean),
# children have radio button instance of check box
Column('isBaseLayer', Boolean),
schema=schema,
)
op.create_table(
'layer_restrictionarea',
Column('layer_id',
Integer,
ForeignKey(schema + '.layer.id'),
primary_key=True),
Column('restrictionarea_id',
Integer,
ForeignKey(schema + '.restrictionarea.id'),
primary_key=True),
schema=schema,
)
op.create_table(
'layergroup_treeitem',
Column('treegroup_id',
Integer,
ForeignKey(schema + '.treegroup.id'),
primary_key=True),
Column('treeitem_id',
Integer,
ForeignKey(schema + '.treeitem.id'),
primary_key=True),
schema=schema,
)
op.create_table(
'theme',
Column('id',
Integer,
ForeignKey(schema + '.treegroup.id'),
primary_key=True),
Column('icon', Unicode),
Column('inMobileViewer', Boolean, default=False),
Column('inDesktopViewer', Boolean, default=True),
schema=schema,
)
op.create_table(
'theme_functionality',
Column('theme_id',
Integer,
ForeignKey(schema + '.theme.id'),
primary_key=True),
Column('functionality_id',
Integer,
ForeignKey(schema + '.functionality.id'),
primary_key=True),
schema=schema,
)
op.execute("INSERT INTO {schema}.treeitem (type, name, \"order\") "
"VALUES ('group', 'background', 0)".format(schema=schema))
op.execute('INSERT INTO {schema}.treegroup (id) SELECT id '
'FROM {schema}.treeitem'.format(schema=schema))
op.execute('INSERT INTO {schema}.layergroup (id) SELECT id '
'FROM {schema}.treeitem'.format(schema=schema))
def upgrade() -> None:
schema = config["schema"]
schema_static = config["schema_static"]
parentschema = config.get("parentschema")
srid = config.get("srid")
engine = op.get_bind().engine
if type(engine).__name__ != "MockConnection" and op.get_context().dialect.has_table(
engine, "functionality", schema=schema
):
return
op.create_table(
"functionality",
Column("id", Integer, primary_key=True),
Column("name", Unicode, nullable=False),
Column("value", Unicode, nullable=False),
Column("description", Unicode),
schema=schema,
)
op.create_table(
"treeitem",
Column("type", String(10), nullable=False),
Column("id", Integer, primary_key=True),
Column("name", Unicode),
Column("order", Integer, nullable=False),
Column("metadataURL", Unicode),
schema=schema,
)
op.create_table(
"restrictionarea",
Column("id", Integer, primary_key=True),
Column("name", Unicode),
Column("description", Unicode),
Column("readwrite", Boolean, default=False),
schema=schema,
)
op.execute(
"SELECT AddGeometryColumn('%(schema)s', 'restrictionarea', "
"'area', %(srid)s, 'POLYGON', 2)" % {"schema": schema, "srid": srid}
)
op.create_table(
"shorturl",
Column("id", Integer, primary_key=True),
Column("url", Unicode(1000)),
Column("ref", String(20), index=True, unique=True, nullable=False),
Column("creator_email", Unicode(200)),
Column("creation", DateTime),
Column("last_hit", DateTime),
Column("nb_hits", Integer),
schema=schema_static,
)
op.create_table(
"role",
Column("id", Integer, primary_key=True),
Column("name", Unicode, unique=True, nullable=False),
Column("description", Unicode),
schema=schema,
)
op.execute(
"SELECT AddGeometryColumn('%(schema)s', 'role', "
"'extent', %(srid)s, 'POLYGON', 2)" % {"schema": schema, "srid": srid}
)
role = Table("role", MetaData(), Column("name", Unicode, unique=True, nullable=False), schema=schema)
op.bulk_insert(role, [{"name": "role_admin"}])
op.create_table(
"layer",
Column("id", Integer, ForeignKey(schema + ".treeitem.id"), primary_key=True),
Column("public", Boolean, default=True),
Column("inMobileViewer", Boolean, default=True),
Column("inDesktopViewer", Boolean, default=True),
Column("isChecked", Boolean, default=True),
Column("icon", Unicode),
Column("layerType", Unicode(12)),
Column("url", Unicode),
Column("imageType", Unicode(10)),
Column("style", Unicode),
Column("dimensions", Unicode),
Column("matrixSet", Unicode),
Column("wmsUrl", Unicode),
Column("wmsLayers", Unicode),
Column("queryLayers", Unicode),
Column("kml", Unicode),
Column("isSingleTile", Boolean),
Column("legend", Boolean, default=True),
Column("legendImage", Unicode),
Column("legendRule", Unicode),
Column("isLegendExpanded", Boolean, default=False),
Column("minResolution", Float),
Column("maxResolution", Float),
Column("disclaimer", Unicode),
Column("identifierAttributeField", Unicode),
Column("geoTable", Unicode),
Column("excludeProperties", Unicode),
Column("timeMode", Unicode(8)),
schema=schema,
)
op.create_table(
"role_restrictionarea",
Column("role_id", Integer, ForeignKey(schema + ".role.id"), primary_key=True),
Column("restrictionarea_id", Integer, ForeignKey(schema + ".restrictionarea.id"), primary_key=True),
schema=schema,
)
op.create_table(
"tsearch",
Column("id", Integer, primary_key=True),
Column("label", Unicode),
Column("layer_name", Unicode),
Column("role_id", Integer, ForeignKey(schema + ".role.id"), nullable=True),
Column("public", Boolean, server_default="true"),
Column("ts", TsVector),
Column("params", Unicode, nullable=True),
schema=schema,
)
op.execute(
"SELECT AddGeometryColumn('%(schema)s', 'tsearch', 'the_geom', "
"%(srid)s, 'GEOMETRY', 2)" % {"schema": schema, "srid": srid}
)
op.create_index("tsearch_ts_idx", "tsearch", ["ts"], schema=schema, postgresql_using="gin")
op.create_table(
"treegroup",
Column("id", Integer, ForeignKey(schema + ".treeitem.id"), primary_key=True),
schema=schema,
)
op.create_table(
"user",
Column("type", String(10), nullable=False),
Column("id", Integer, primary_key=True),
Column("username", Unicode, unique=True, nullable=False),
Column("password", Unicode, nullable=False),
Column("email", Unicode, nullable=False),
Column("is_password_changed", Boolean, default=False),
Column("role_id", Integer, ForeignKey(schema + ".role.id"), nullable=False),
schema=schema,
)
if parentschema is not None and parentschema != "":
op.add_column(
"user", Column("parent_role_id", Integer, ForeignKey(parentschema + ".role.id")), schema=schema
)
op.execute(
"INSERT INTO %(schema)s.user (type, username, email, password, role_id) "
"(SELECT 'user', 'admin', '*****@*****.**', '%(pass)s', r.id "
"FROM %(schema)s.role AS r "
"WHERE r.name = 'role_admin')" % {"schema": schema, "pass": sha1("admin".encode("utf-8")).hexdigest()}
)
op.create_table(
"role_functionality",
Column("role_id", Integer, ForeignKey(schema + ".role.id"), primary_key=True),
Column("functionality_id", Integer, ForeignKey(schema + ".functionality.id"), primary_key=True),
schema=schema,
)
op.create_table(
"user_functionality",
Column("user_id", Integer, ForeignKey(schema + ".user.id"), primary_key=True),
Column("functionality_id", Integer, ForeignKey(schema + ".functionality.id"), primary_key=True),
schema=schema,
)
op.create_table(
"layergroup",
Column("id", Integer, ForeignKey(schema + ".treegroup.id"), primary_key=True),
Column("isExpanded", Boolean),
Column("isInternalWMS", Boolean),
# children have radio button instance of check box
Column("isBaseLayer", Boolean),
schema=schema,
)
op.create_table(
"layer_restrictionarea",
Column("layer_id", Integer, ForeignKey(schema + ".layer.id"), primary_key=True),
Column("restrictionarea_id", Integer, ForeignKey(schema + ".restrictionarea.id"), primary_key=True),
schema=schema,
)
op.create_table(
"layergroup_treeitem",
Column("treegroup_id", Integer, ForeignKey(schema + ".treegroup.id"), primary_key=True),
Column("treeitem_id", Integer, ForeignKey(schema + ".treeitem.id"), primary_key=True),
schema=schema,
)
op.create_table(
"theme",
Column("id", Integer, ForeignKey(schema + ".treegroup.id"), primary_key=True),
Column("icon", Unicode),
Column("inMobileViewer", Boolean, default=False),
Column("inDesktopViewer", Boolean, default=True),
schema=schema,
)
op.create_table(
"theme_functionality",
Column("theme_id", Integer, ForeignKey(schema + ".theme.id"), primary_key=True),
Column("functionality_id", Integer, ForeignKey(schema + ".functionality.id"), primary_key=True),
schema=schema,
)
op.execute(
'INSERT INTO {schema}.treeitem (type, name, "order") '
"VALUES ('group', 'background', 0)".format(schema=schema)
)
op.execute(
"INSERT INTO {schema}.treegroup (id) SELECT id " "FROM {schema}.treeitem".format(schema=schema)
)
op.execute(
"INSERT INTO {schema}.layergroup (id) SELECT id " "FROM {schema}.treeitem".format(schema=schema)
)
def upgrade():
schema = config['schema']
staticschema = config['schema_static']
parentschema = config.get('parentschema')
engine = op.get_bind().engine
if type(engine).__name__ != 'MockConnection' and \
op.get_context().dialect.has_table(
engine, 'user', schema=staticschema): # pragma: no cover
return
op.create_table(
'user',
Column('type', String(10), nullable=False),
Column('id', Integer, primary_key=True),
Column('username', Unicode, unique=True, nullable=False),
Column('password', Unicode, nullable=False),
Column('email', Unicode, nullable=False),
Column('is_password_changed', Boolean, default=False),
Column('role_name', String),
schema=staticschema,
)
parent_column = ''
parent_select = ''
parent_join = ''
if parentschema is not None and parentschema is not '': # pragma: no cover
op.add_column(
'user',
Column('parent_role_name', String),
schema=staticschema
)
parent_column = ', parent_role_name'
parent_select = ', pr.name'
parent_join = (
'LEFT OUTER JOIN {parentschema!s}.role AS pr ON (pr.id = u.parent_role_id)'.format(
parentschema=parentschema,
)
)
try:
op.execute(
'INSERT INTO %(staticschema)s.user '
'(type, username, password, email, is_password_changed, role_name%(parent_column)s) ('
'SELECT u.type, u.username, u.password, u.email, '
'u.is_password_changed, r.name%(parent_select)s '
'FROM %(schema)s.user AS u '
'LEFT OUTER JOIN %(schema)s.role AS r ON (r.id = u.role_id) %(parent_join)s'
')' % {
'staticschema': staticschema,
'schema': schema,
'parent_select': parent_select,
'parent_column': parent_column,
'parent_join': parent_join,
}
)
op.drop_table('user', schema=schema)
except Exception:
op.execute(
"INSERT INTO %(staticschema)s.user (type, username, email, password, role) "
"VALUES ( 'user', 'admin', '*****@*****.**', '%(pass)s', 'role_admin')" % {
'staticschema': staticschema,
'pass': sha1('admin'.encode('utf-8')).hexdigest()
}
)
