def test_export_data_in_pg(self):
print("\nINFO: Validate Export Data in PG...")
restore_schema('test_export_data')
db_pg = get_pg_conn('test_export_data')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = ExportConfiguration()
configuration.base_configuration = base_config
configuration.dbhost = 'postgres'
configuration.dbusr = '******'
configuration.dbpwd = 'clave_ladm_col'
configuration.database = 'ladm_col'
configuration.dbschema = 'test_export_data'
configuration.delete_data = True
configuration.ilimodels = ';'.join([self.ladmcol_models.model(LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()])
exporter = iliexporter.Exporter()
exporter.tool = DbIliMode.ili2pg
exporter.configuration = configuration
exporter.configuration.xtffile = os.path.join(tempfile.mkdtemp(), 'test_export_data.xtf')
self.assertEqual(exporter.run(), iliexporter.Exporter.SUCCESS)
self.check_export_xtf(exporter.configuration.xtffile)
db_pg.conn.close()
def __init__(self, iface):
QObject.__init__(self)
self.iface = iface
self.plugin_dir = os.path.dirname(__file__)
self.__generate_action = None
self.__export_action = None
self.__importdata_action = None
self.__configure_action = None
self.__help_action = None
self.__about_action = None
self.__separator = None
if locale.getlocale() == (None, None):
locale.setlocale(locale.LC_ALL, '')
# initialize translation
qgis_locale_id = str(QSettings().value('locale/userLocale'))
qgis_locale = QLocale(qgis_locale_id)
locale_path = os.path.join(self.plugin_dir, 'i18n')
self.translator = QTranslator()
self.translator.load(qgis_locale, 'QgisModelBaker', '_', locale_path)
QCoreApplication.installTranslator(self.translator)
self.ili2db_configuration = BaseConfiguration()
settings = QSettings()
settings.beginGroup('QgisModelBaker/ili2db')
self.ili2db_configuration.restore(settings)
def test_import_schema_in_gpkg(self):
print("\nINFO: Validate Import Schema in GPKG...")
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = SchemaImportConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2gpkg
configuration.dbfile = os.path.join(self.base_test_path, 'tmp_import_schema.gpkg')
configuration.tomlfile = TOML_FILE_DIR
configuration.srs_code = 3116
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.ilimodels = ';'.join([self.ladmcol_models.model(LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.CADASTRAL_CARTOGRAPHY_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.VALUATION_MODEL_KEY).full_name()])
importer = iliimporter.Importer()
importer.tool = DbIliMode.ili2gpkg
importer.configuration = configuration
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
config_manager = GpkgCommandConfigManager(importer.configuration)
generator = Generator(DbIliMode.ili2gpkg, config_manager.get_uri(), configuration.inheritance)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 184)
def test_export_data_in_gpkg(self):
print("\nINFO: Validate Export Data in GPKG...")
gpkg_path = get_test_copy_path('geopackage/test_export_data.gpkg')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path('models/LADM_COL')
base_config.custom_model_directories_enabled = True
configuration = ExportConfiguration()
configuration.base_configuration = base_config
configuration.ilimodels = ';'.join([
LADMNames.SUPPORTED_LADM_MODEL, LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL, LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_VALUATION_MODEL
])
configuration.dbfile = gpkg_path
exporter = iliexporter.Exporter()
exporter.tool = DbIliMode.ili2gpkg
exporter.configuration = configuration
exporter.configuration.xtffile = os.path.join(self.base_test_path,
'test_export_data.xtf')
self.assertEqual(exporter.run(), iliexporter.Exporter.SUCCESS)
self.check_export_xtf(exporter.configuration.xtffile)
def test_export_data_in_gpkg(self):
print("\nINFO: Validate Export Data in GPKG...")
gpkg_path = get_test_copy_path(
'geopackage/test_export_data_ladm_v1_0.gpkg')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = ExportConfiguration()
configuration.base_configuration = base_config
configuration.ilimodels = ';'.join([
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()
])
configuration.dbfile = gpkg_path
exporter = iliexporter.Exporter()
exporter.tool = DbIliMode.ili2gpkg
exporter.configuration = configuration
exporter.configuration.xtffile = os.path.join(self.base_test_path,
'test_export_data.xtf')
# exporter.stderr.connect(self.on_stderr)
self.assertEqual(exporter.run(), iliexporter.Exporter.SUCCESS)
self.check_export_xtf(exporter.configuration.xtffile)
def test_import_data_in_mssql(self):
print("\nINFO: Validate Import Data in MS SQL Server...")
schema = 'test_ladm_col'
reset_db_mssql(schema)
restore_schema_mssql(schema)
db_conn = get_mssql_conn(schema)
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
model_list = [self.ladmcol_models.model(LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()]
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.dbhost = 'mssql'
configuration.dbusr = '******'
configuration.dbpwd = '<YourStrong!Passw0rd>'
configuration.dbport = '1433'
configuration.database = schema # use schema because delete schemas in mssql is difficult
configuration.dbschema = schema
configuration.db_odbc_driver = 'ODBC Driver 17 for SQL Server'
configuration.delete_data = True
configuration.ilimodels = ';'.join(model_list)
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2mssql
importer.configuration = configuration
importer.configuration.xtffile = testdata_path('xtf/test_ladm_col_queries_v1_0.xtf')
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
generator = Generator(DbIliMode.ili2mssql,
'DRIVER={{ODBC Driver 17 for SQL Server}};SERVER={host},1433;DATABASE={db};UID={user};PWD={pwd}'
.format(db=configuration.database, user=configuration.dbusr, pwd=configuration.dbpwd,
host=configuration.dbhost, port=configuration.dbport), configuration.inheritance,
importer.configuration.dbschema)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 156)
res, code, msg = db_conn.test_connection()
self.assertTrue(res, msg)
test_layer = self.app.core.get_layer(db_conn, db_conn.names.LC_BOUNDARY_POINT_T, load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_conn.conn.close()
def test_import_schema_in_mssql(self):
schema = 'test_import_schema'
reset_db_mssql(schema)
print("\nINFO: Validate Import Schema in MS SQL Server")
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(
'xtf') + ';' + testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = SchemaImportConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2mssql
configuration.dbhost = 'mssql'
configuration.dbusr = '******'
configuration.dbpwd = '<YourStrong!Passw0rd>'
configuration.dbport = '1433'
configuration.database = schema
configuration.dbschema = schema
configuration.db_odbc_driver = 'ODBC Driver 17 for SQL Server'
configuration.tomlfile = TOML_FILE_DIR
configuration.epsg = 9377
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.ilimodels = ';'.join([
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()
])
importer = iliimporter.Importer()
importer.tool = DbIliMode.ili2mssql
importer.configuration = configuration
# importer.stderr.connect(self.on_stderr)
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
generator = Generator(
DbIliMode.ili2mssql,
'DRIVER={{ODBC Driver 17 for SQL Server}};SERVER={host},1433;DATABASE={db};UID={user};PWD={pwd}'
.format(db=configuration.database,
user=configuration.dbusr,
pwd=configuration.dbpwd,
host=configuration.dbhost,
port=configuration.dbport), configuration.inheritance,
importer.configuration.dbschema)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 156)
def test_import_data_in_gpkg(self):
print("\nINFO: Validate Import Data in GPKG...")
gpkg_path = get_test_copy_path(
'geopackage/test_import_data_ladm_v1_0.gpkg')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2gpkg
configuration.dbfile = gpkg_path
configuration.srs_auth = DEFAULT_SRS_AUTH
configuration.srs_code = DEFAULT_SRS_CODE
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.delete_data = True
configuration.ilimodels = ';'.join([
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()
])
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2gpkg
importer.configuration = configuration
importer.configuration.xtffile = testdata_path(
'xtf/test_ladm_col_queries_v1_0.xtf')
# importer.stderr.connect(self.on_stderr)
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
config_manager = GpkgCommandConfigManager(importer.configuration)
generator = Generator(DbIliMode.ili2gpkg, config_manager.get_uri(),
configuration.inheritance)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 156)
db_gpkg = get_gpkg_conn_from_path(config_manager.get_uri())
res, code, msg = db_gpkg.test_connection()
self.assertTrue(res, msg)
test_layer = self.app.core.get_layer(db_gpkg,
db_gpkg.names.LC_BOUNDARY_POINT_T,
load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_gpkg.conn.close()
def test_import_data_in_pg(self):
print("\nINFO: Validate Import Data in PG...")
restore_schema('test_import_data')
db_pg = get_pg_conn('test_import_data')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path('models/LADM_COL')
base_config.custom_model_directories_enabled = True
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.dbhost = 'postgres'
configuration.dbusr = '******'
configuration.dbpwd = 'clave_ladm_col'
configuration.database = 'ladm_col'
configuration.epsg = DEFAULT_EPSG
configuration.inheritance = LADMNames.DEFAULT_INHERITANCE
configuration.create_basket_col = LADMNames.CREATE_BASKET_COL
configuration.create_import_tid = LADMNames.CREATE_IMPORT_TID
configuration.stroke_arcs = LADMNames.STROKE_ARCS
configuration.dbschema = 'test_import_data'
configuration.delete_data = True
configuration.ilimodels = ';'.join([
LADMNames.SUPPORTED_LADM_MODEL, LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL, LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_VALUATION_MODEL
])
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2pg
importer.configuration = configuration
importer.configuration.xtffile = testdata_path(
'xtf/test_ladm_col_queries_v2.9.6.xtf')
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
generator = Generator(
DbIliMode.ili2pg, 'dbname={} user={} password={} host={}'.format(
configuration.database, configuration.dbusr,
configuration.dbpwd, configuration.dbhost),
configuration.inheritance, importer.configuration.dbschema)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 189)
res, code, msg = db_pg.test_connection()
self.assertTrue(res, msg)
test_layer = self.qgis_utils.get_layer(db_pg,
db_pg.names.OP_BOUNDARY_POINT_T,
load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_pg.conn.close()
def test_import_data_in_pg(self):
print("\nINFO: Validate Import Data in PG...")
restore_schema('test_import_data')
db_pg = get_pg_conn('test_import_data')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.dbhost = 'postgres'
configuration.dbusr = '******'
configuration.dbpwd = 'clave_ladm_col'
configuration.database = 'ladm_col'
configuration.srs_auth = DEFAULT_SRS_AUTH
configuration.srs_code = DEFAULT_SRS_CODE
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.dbschema = 'test_import_data'
configuration.delete_data = True
configuration.ilimodels = ';'.join([self.ladmcol_models.model(LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()])
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2pg
importer.configuration = configuration
importer.configuration.xtffile = testdata_path('xtf/test_ladm_col_queries_v1_0.xtf')
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
generator = Generator(
DbIliMode.ili2pg,
'dbname={} user={} password={} host={}'.format(configuration.database, configuration.dbusr,
configuration.dbpwd, configuration.dbhost),
configuration.inheritance,
importer.configuration.dbschema)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 156)
res, code, msg = db_pg.test_connection()
self.assertTrue(res, msg)
test_layer = self.app.core.get_layer(db_pg, db_pg.names.LC_BOUNDARY_POINT_T, load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_pg.conn.close()
def test_import_schema_in_pg(self):
print("\nINFO: Validate Import Schema in PG...")
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(
'xtf') + ';' + testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = SchemaImportConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2pg
configuration.dbhost = 'postgres'
configuration.dbusr = '******'
configuration.dbpwd = 'clave_ladm_col'
configuration.database = 'ladm_col'
configuration.dbschema = 'test_import_schema'
configuration.tomlfile = TOML_FILE_DIR
configuration.srs_code = 3116
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.ilimodels = ';'.join([
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.CADASTRAL_CARTOGRAPHY_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.VALUATION_MODEL_KEY).full_name()
])
importer = iliimporter.Importer()
importer.tool = DbIliMode.ili2pg
importer.configuration = configuration
# importer.stderr.connect(self.on_stderr)
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
generator = Generator(
DbIliMode.ili2pg, 'dbname={} user={} password={} host={}'.format(
configuration.database, configuration.dbusr,
configuration.dbpwd, configuration.dbhost),
configuration.inheritance, importer.configuration.dbschema)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 184)
def test_import_data_in_gpkg(self):
print("\nINFO: Validate Import Data in GPKG...")
gpkg_path = get_test_copy_path('geopackage/test_import_data.gpkg')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path('models/LADM_COL')
base_config.custom_model_directories_enabled = True
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2gpkg
configuration.dbfile = gpkg_path
configuration.epsg = DEFAULT_EPSG
configuration.inheritance = LADMNames.DEFAULT_INHERITANCE
configuration.create_basket_col = LADMNames.CREATE_BASKET_COL
configuration.create_import_tid = LADMNames.CREATE_IMPORT_TID
configuration.stroke_arcs = LADMNames.STROKE_ARCS
configuration.delete_data = True
configuration.ilimodels = ';'.join([
LADMNames.SUPPORTED_LADM_MODEL, LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL, LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_VALUATION_MODEL
])
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2gpkg
importer.configuration = configuration
importer.configuration.xtffile = testdata_path(
'xtf/test_ladm_col_queries_v2.9.6.xtf')
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
config_manager = GpkgCommandConfigManager(importer.configuration)
generator = Generator(DbIliMode.ili2gpkg, config_manager.get_uri(),
configuration.inheritance)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 189)
db_gpkg = get_gpkg_conn_from_path(config_manager.get_uri())
res, code, msg = db_gpkg.test_connection()
self.assertTrue(res, msg)
test_layer = self.qgis_utils.get_layer(
db_gpkg, db_gpkg.names.OP_BOUNDARY_POINT_T, load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_gpkg.conn.close()
def test_export_data_in_mssql(self):
print("\nINFO: Validate Export Data in MS SQL Server...")
schema = 'test_export_data'
reset_db_mssql(schema)
restore_schema_mssql(schema)
db_conn = get_mssql_conn(schema)
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
model_list = [
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()
]
configuration = ExportConfiguration()
configuration.base_configuration = base_config
configuration.dbhost = 'mssql'
configuration.dbusr = '******'
configuration.dbpwd = '<YourStrong!Passw0rd>'
configuration.dbport = '1433'
configuration.database = schema # use schema because delete schemas in mssql is difficult
configuration.dbschema = schema
configuration.db_odbc_driver = 'ODBC Driver 17 for SQL Server'
configuration.delete_data = True
configuration.ilimodels = ';'.join(model_list)
exporter = iliexporter.Exporter()
exporter.tool = DbIliMode.ili2mssql
exporter.configuration = configuration
exporter.configuration.xtffile = os.path.join(tempfile.mkdtemp(),
'test_export_data.xtf')
# exporter.stderr.connect(self.on_stderr)
self.assertEqual(exporter.run(), iliexporter.Exporter.SUCCESS)
self.check_export_xtf(exporter.configuration.xtffile)
db_conn.conn.close()
def __init__(self, iface):
QObject.__init__(self)
self.iface = iface
self.plugin_dir = os.path.dirname(__file__)
self.generate_dlg = None
self.export_dlg = None
self.importdata_dlg = None
self.workflow_wizard_dlg = None
self.datasetmanager_dlg = None
self.__generate_action = None
self.__export_action = None
self.__importdata_action = None
self.__workflow_wizard_action = None
self.__datasetmanager_action = None
self.__validate_action = None
self.__configure_action = None
self.__help_action = None
self.__about_action = None
self.__separator = None
self.__dataset_selector_action = None
self.__dataset_selector = None
self.__validate_dock = None
basepath = pathlib.Path(__file__).parent.absolute()
metadata = configparser.ConfigParser()
metadata.read(os.path.join(basepath, "metadata.txt"))
self.__version__ = metadata["general"]["version"]
if locale.getlocale() == (None, None):
locale.setlocale(locale.LC_ALL, "")
# initialize translation
qgis_locale_id = str(QSettings().value("locale/userLocale"))
qgis_locale = QLocale(qgis_locale_id)
locale_path = os.path.join(self.plugin_dir, "i18n")
self.translator = QTranslator()
self.translator.load(qgis_locale, "QgisModelBaker", "_", locale_path)
QCoreApplication.installTranslator(self.translator)
self.ili2db_configuration = BaseConfiguration()
settings = QSettings()
settings.beginGroup("QgisModelBaker/ili2db")
self.ili2db_configuration.restore(settings)
self.event_filter = DropFileFilter(self)
def test_import_schema_in_pg(self):
print("\nINFO: Validate Import Schema in PG...")
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(
'xtf') + ';' + testdata_path('models/LADM_COL')
base_config.custom_model_directories_enabled = True
configuration = SchemaImportConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2pg
configuration.dbhost = 'postgres'
configuration.dbusr = '******'
configuration.dbpwd = 'clave_ladm_col'
configuration.database = 'ladm_col'
configuration.dbschema = 'test_import_schema'
configuration.tomlfile = TOML_FILE_DIR
configuration.epsg = DEFAULT_EPSG
configuration.inheritance = LADMNames.DEFAULT_INHERITANCE
configuration.create_basket_col = LADMNames.CREATE_BASKET_COL
configuration.create_import_tid = LADMNames.CREATE_IMPORT_TID
configuration.stroke_arcs = LADMNames.STROKE_ARCS
configuration.ilimodels = ';'.join([
LADMNames.SUPPORTED_LADM_MODEL, LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL, LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_REFERENCE_CARTOGRAPHY,
LADMNames.SUPPORTED_VALUATION_MODEL
])
importer = iliimporter.Importer()
importer.tool = DbIliMode.ili2pg
importer.configuration = configuration
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
generator = Generator(
DbIliMode.ili2pg, 'dbname={} user={} password={} host={}'.format(
configuration.database, configuration.dbusr,
configuration.dbpwd, configuration.dbhost),
configuration.inheritance, importer.configuration.dbschema)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 207)
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.xtf_file_browse_button.clicked.connect(
make_save_file_selector(self.xtf_file_line_edit, title=QCoreApplication.translate("DialogExportData", "Save in XTF Transfer File"),
file_filter=QCoreApplication.translate("DialogExportData", "XTF Transfer File (*.xtf);;Interlis 1 Transfer File (*.itf);;XML (*.xml);;GML (*.gml)"), extension='.xtf', extensions=['.' + ext for ext in self.ValidExtensions]))
self.xtf_file_browse_button.clicked.connect(self.xtf_browser_opened_to_true)
self.xtf_browser_was_opened = False
self.validators = Validators()
fileValidator = FileValidator(pattern=['*.' + ext for ext in self.ValidExtensions], allow_non_existing=True)
self.xtf_file_line_edit.setPlaceholderText(QCoreApplication.translate("DialogExportData", "[Name of the XTF to be created]"))
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.connect(self.xtf_browser_opened_to_false)
self.xtf_file_line_edit.textChanged.emit(self.xtf_file_line_edit.text())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(QCoreApplication.translate("DialogExportData", "Connection Settings"))
# LOG
self.log_config.setTitle(QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(QCoreApplication.translate("DialogExportData", "Export data"), QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.update_model_names()
self.restore_configuration()
def test_import_schema_in_gpkg(self):
print("\nINFO: Validate Import Schema in GPKG...")
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path('models/LADM_COL')
base_config.custom_model_directories_enabled = True
configuration = SchemaImportConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2gpkg
configuration.dbfile = os.path.join(self.base_test_path,
'tmp_import_schema.gpkg')
configuration.tomlfile = TOML_FILE_DIR
configuration.epsg = DEFAULT_EPSG
configuration.inheritance = LADMNames.DEFAULT_INHERITANCE
configuration.create_basket_col = LADMNames.CREATE_BASKET_COL
configuration.create_import_tid = LADMNames.CREATE_IMPORT_TID
configuration.stroke_arcs = LADMNames.STROKE_ARCS
configuration.ilimodels = ';'.join([
LADMNames.SUPPORTED_LADM_MODEL, LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL, LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_REFERENCE_CARTOGRAPHY,
LADMNames.SUPPORTED_VALUATION_MODEL
])
importer = iliimporter.Importer()
importer.tool = DbIliMode.ili2gpkg
importer.configuration = configuration
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
config_manager = GpkgCommandConfigManager(importer.configuration)
generator = Generator(DbIliMode.ili2gpkg, config_manager.get_uri(),
configuration.inheritance)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 207)
def __init__(self, iface):
QObject.__init__(self)
self.iface = iface
self.plugin_dir = os.path.dirname(__file__)
self.generate_dlg = None
self.export_dlg = None
self.importdata_dlg = None
self.__generate_action = None
self.__export_action = None
self.__importdata_action = None
self.__configure_action = None
self.__help_action = None
self.__about_action = None
self.__separator = None
basepath = pathlib.Path(__file__).parent.absolute()
metadata = configparser.ConfigParser()
metadata.read(os.path.join(basepath, 'metadata.txt'))
self.__version__ = metadata['general']['version']
if locale.getlocale() == (None, None):
locale.setlocale(locale.LC_ALL, '')
# initialize translation
qgis_locale_id = str(QSettings().value('locale/userLocale'))
qgis_locale = QLocale(qgis_locale_id)
locale_path = os.path.join(self.plugin_dir, 'i18n')
self.translator = QTranslator()
self.translator.load(qgis_locale, 'QgisModelBaker', '_', locale_path)
QCoreApplication.installTranslator(self.translator)
self.ili2db_configuration = BaseConfiguration()
settings = QSettings()
settings.beginGroup('QgisModelBaker/ili2db')
self.ili2db_configuration.restore(settings)
self.event_filter = DropFileFilter(self)
def __init__(self, parent, db_action_type):
DbConfigPanel.__init__(self, parent, db_action_type)
self.setupUi(self)
from QgisModelBaker.libili2db.ili2dbconfig import BaseConfiguration
self.pg_use_super_login.setText(
self.
tr("Execute data management tasks with superuser login from settings ({})"
).format(BaseConfiguration().super_pg_user))
self.pg_use_super_login.setToolTip(
self.
tr("Data management tasks are <ul><li>Create the schema</li><li>Read meta information</li><li>Import data from XTF</li><li>Export data to XTF</li></ul>"
))
if self._db_action_type == DbActionType.GENERATE:
self.pg_schema_line_edit.setPlaceholderText(
self.tr("[Leave empty to create a default schema]"))
elif self._db_action_type == DbActionType.IMPORT_DATA:
self.pg_schema_line_edit.setPlaceholderText(
self.tr("[Leave empty to import data into a default schema]"))
elif self._db_action_type == DbActionType.EXPORT:
self.pg_schema_line_edit.setPlaceholderText(
self.tr("[Leave empty to load all schemas in the database]"))
# define validators
self.validators = Validators()
nonEmptyValidator = NonEmptyStringValidator()
self.pg_host_line_edit.setValidator(nonEmptyValidator)
self.pg_database_line_edit.setValidator(nonEmptyValidator)
self.pg_host_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.pg_host_line_edit.textChanged.emit(self.pg_host_line_edit.text())
self.pg_database_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.pg_database_line_edit.textChanged.emit(
self.pg_database_line_edit.text())
self.pg_host_line_edit.textChanged.connect(self.notify_fields_modified)
self.pg_port_line_edit.textChanged.connect(self.notify_fields_modified)
self.pg_database_line_edit.textChanged.connect(
self.notify_fields_modified)
self.pg_schema_line_edit.textChanged.connect(
self.notify_fields_modified)
def __init__(self, iface, qgis_utils, conn_manager,
selected_models=list()):
QDialog.__init__(self)
self.iface = iface
self.conn_manager = conn_manager
self.selected_models = selected_models
self.db = self.conn_manager.get_db_connector_from_source()
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.setupUi(self)
self.validators = Validators()
self.update_import_models()
self.previous_item = QListWidgetItem()
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportSchema",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportSchema", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_schema)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_CREATE_STRUCTURE, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.setupUi(self)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.validators = Validators()
self.update_import_models()
self.previous_item = QListWidgetItem()
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportSchema",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportSchema", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogImportSchema",
"Create LADM-COL structure"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
class QgisModelBakerPlugin(QObject):
def __init__(self, iface):
QObject.__init__(self)
self.iface = iface
self.plugin_dir = os.path.dirname(__file__)
self.generate_dlg = None
self.export_dlg = None
self.importdata_dlg = None
self.__generate_action = None
self.__export_action = None
self.__importdata_action = None
self.__configure_action = None
self.__help_action = None
self.__about_action = None
self.__separator = None
basepath = pathlib.Path(__file__).parent.absolute()
metadata = configparser.ConfigParser()
metadata.read(os.path.join(basepath, 'metadata.txt'))
self.__version__ = metadata['general']['version']
if locale.getlocale() == (None, None):
locale.setlocale(locale.LC_ALL, '')
# initialize translation
qgis_locale_id = str(QSettings().value('locale/userLocale'))
qgis_locale = QLocale(qgis_locale_id)
locale_path = os.path.join(self.plugin_dir, 'i18n')
self.translator = QTranslator()
self.translator.load(qgis_locale, 'QgisModelBaker', '_', locale_path)
QCoreApplication.installTranslator(self.translator)
self.ili2db_configuration = BaseConfiguration()
settings = QSettings()
settings.beginGroup('QgisModelBaker/ili2db')
self.ili2db_configuration.restore(settings)
self.event_filter = DropFileFilter(self)
def register_event_filter(self):
if not self.event_filter:
self.event_filter = DropFileFilter(self)
self.iface.mainWindow().installEventFilter(self.event_filter)
def unregister_event_filter(self):
if self.event_filter:
self.iface.mainWindow().removeEventFilter(self.event_filter)
self.event_filter.deleteLater()
def initGui(self):
pyplugin_installer.installer.initPluginInstaller()
pyplugin_installer.installer_data.plugins.rebuild()
if 'projectgenerator' in available_plugins:
pyplugin_installer.instance().uninstallPlugin('projectgenerator',
quiet=True)
self.__generate_action = QAction(
QIcon(
os.path.join(os.path.dirname(__file__),
'images/QgisModelBaker-icon.svg')),
self.tr('Generate'), None)
self.__export_action = QAction(
QIcon(
os.path.join(os.path.dirname(__file__),
'images/QgisModelBaker-xtf-export-icon.svg')),
self.tr('Export Interlis Transfer File (.xtf)'), None)
self.__importdata_action = QAction(
QIcon(
os.path.join(os.path.dirname(__file__),
'images/QgisModelBaker-xtf-import-icon.svg')),
self.tr('Import Interlis Transfer File (.xtf)'), None)
self.__configure_action = QAction(self.tr('Settings'), None)
self.__help_action = QAction(self.tr('Help'), None)
self.__about_action = QAction(self.tr('About'), None)
self.__separator = QAction(None)
self.__separator.setSeparator(True)
# set these actions checkable to visualize that the dialog is open
self.__generate_action.setCheckable(True)
self.__export_action.setCheckable(True)
self.__importdata_action.setCheckable(True)
self.__generate_action.triggered.connect(self.show_generate_dialog)
self.__configure_action.triggered.connect(self.show_options_dialog)
self.__importdata_action.triggered.connect(self.show_importdata_dialog)
self.__export_action.triggered.connect(self.show_export_dialog)
self.__help_action.triggered.connect(self.show_help_documentation)
self.__about_action.triggered.connect(self.show_about_dialog)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__generate_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__importdata_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__export_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__configure_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__separator)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__help_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__about_action)
self.toolbar = self.iface.addToolBar(self.tr('Model Baker'))
self.toolbar.setObjectName("ModelBakerToolbar")
self.toolbar.setToolTip(self.tr('Model Baker Toolbar'))
self.toolbar.addAction(self.__generate_action)
self.toolbar.addAction(self.__importdata_action)
self.toolbar.addAction(self.__export_action)
self.register_event_filter()
def unload(self):
self.unregister_event_filter()
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__generate_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__importdata_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__export_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__configure_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__help_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__about_action)
del self.__generate_action
del self.__export_action
del self.__importdata_action
del self.__configure_action
del self.__help_action
del self.__about_action
def show_generate_dialog(self):
if self.generate_dlg:
self.generate_dlg.reject()
else:
self.generate_dlg = GenerateProjectDialog(
self.iface, self.ili2db_configuration, self.iface.mainWindow())
self.generate_dlg.setAttribute(Qt.WA_DeleteOnClose)
self.generate_dlg.setWindowFlags(self.generate_dlg.windowFlags()
| Qt.Tool)
self.generate_dlg.show()
self.generate_dlg.finished.connect(self.generate_dialog_finished)
self.__generate_action.setChecked(True)
def generate_dialog_finished(self):
self.__generate_action.setChecked(False)
self.generate_dlg = None
def show_export_dialog(self):
if self.export_dlg:
self.export_dlg.reject()
else:
self.export_dlg = ExportDialog(self.ili2db_configuration,
self.iface.mainWindow())
self.export_dlg.setAttribute(Qt.WA_DeleteOnClose)
self.export_dlg.setWindowFlags(self.export_dlg.windowFlags()
| Qt.Tool)
self.export_dlg.show()
self.export_dlg.finished.connect(self.export_dialog_finished)
self.__export_action.setChecked(True)
def export_dialog_finished(self):
self.__export_action.setChecked(False)
self.export_dlg = None
def show_importdata_dialog(self):
if self.importdata_dlg:
self.importdata_dlg.reject()
else:
self.importdata_dlg = ImportDataDialog(self.iface,
self.ili2db_configuration,
self.iface.mainWindow())
self.importdata_dlg.setAttribute(Qt.WA_DeleteOnClose)
self.importdata_dlg.setWindowFlags(
self.importdata_dlg.windowFlags() | Qt.Tool)
self.importdata_dlg.show()
self.importdata_dlg.finished.connect(
self.importdata_dialog_finished)
self.__importdata_action.setChecked(True)
def importdata_dialog_finished(self):
self.__importdata_action.setChecked(False)
self.importdata_dlg = None
def show_options_dialog(self):
dlg = OptionsDialog(self.ili2db_configuration)
if dlg.exec_():
settings = QSettings()
settings.beginGroup('QgisModelBaker/ili2db')
self.ili2db_configuration.save(settings)
def show_help_documentation(self):
os_language = QLocale(
QSettings().value('locale/userLocale')).name()[:2]
if os_language in ['es', 'de']:
webbrowser.open(
'https://opengisch.github.io/QgisModelBaker/docs/{}/'.format(
os_language))
else:
webbrowser.open(
'https://opengisch.github.io/QgisModelBaker/docs/index.html')
def show_about_dialog(self):
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Information)
self.msg.setTextFormat(Qt.RichText)
self.msg.setWindowTitle(self.tr('About Model Baker'))
self.msg.setText("""<h1>{title}</h1>
<p align="justify"><small>{version}</small></p>
<p align="justify">{p1}</p>
<p align="justify">{p2}</p>
<p align="justify">{p3}</p>""".format(
title=self.tr('QGIS Model Baker'),
version=self.tr('Version {version}').format(
version=self.__version__),
p1=self.
tr('Configuring QGIS layers and forms manually is a tedious and error prone process. This plugin loads database schemas with various meta information to preconfigure the layer tree, widget configuration, relations and more.'
),
p2=self.
tr('This project is open source under the terms of the GPLv2 or later and the source code can be found on <a href="https://github.com/opengisch/QgisModelBaker">github</a>.'
),
p3=self.
tr('This plugin is developed by <a href="https://www.opengis.ch/">OPENGIS.ch</a> in collaboration with <a href="https://swisstierrascolombia.com">SwissTierras Colombia</a>'
)))
self.msg.setStandardButtons(QMessageBox.Close)
msg_box = self.msg.exec_()
def get_generator(self):
return Generator
def create_project(self,
layers,
relations,
bags_of_enum,
legend,
auto_transaction=True,
evaluate_default_values=True):
"""
Expose the main functionality from Model Baker to other plugins,
namely, create a QGIS project from objects obtained from the Generator
class.
:param layers: layers object from generator.layers
:param relations: relations object obtained from generator.relations
:param bags_of_enum: bags_of_enum object from generator.relations
:param legend: legend object obtained from generator.legend
:param auto_transaction: whether transactions should be enabled or not
when editing layers from supported DB like PG
:param evaluate_default_values: should default values be evaluated on
provider side when requested and not
when committed. (from QGIS docs)
"""
project = Project(auto_transaction, evaluate_default_values)
project.layers = layers
project.relations = relations
project.bags_of_enum = bags_of_enum
project.legend = legend
project.post_generate()
qgis_project = QgsProject.instance()
project.create(None, qgis_project)
def handle_dropped_file(self, file_path):
if pathlib.Path(file_path).suffix[1:] in ['xtf', 'XTF', 'itf', 'ITF']:
if not self.importdata_dlg:
self.set_dropped_file_configuration(file_path)
self.show_importdata_dialog()
return True
return False
def set_dropped_file_configuration(self, file_path):
settings = QSettings()
settings.setValue('QgisModelBaker/ili2pg/xtffile_import', file_path)
settings.setValue('QgisModelBaker/importtype', 'gpkg')
output_file_name = '{}_{:%Y%m%d%H%M%S%f}.gpkg'.format(
os.path.splitext(os.path.basename(file_path))[0],
datetime.datetime.now())
settings.setValue(
'QgisModelBaker/ili2gpkg/dbfile',
os.path.join(
QStandardPaths.writableLocation(QStandardPaths.TempLocation),
output_file_name))
def __init__(self,
iface,
conn_manager,
context,
selected_models=list(),
link_to_import_data=True,
parent=None):
QDialog.__init__(self, parent)
self.iface = iface
self.conn_manager = conn_manager
self.selected_models = selected_models
self.link_to_import_data = link_to_import_data
self.logger = Logger()
self.app = AppInterface()
self.__ladmcol_models = LADMColModelRegistry()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.db_source = context.get_db_sources()[0]
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be two cases where we need to emit a db_connection_changed from the Schema Import dialog:
# 1) Connection Settings was opened and the DB conn was changed.
# 2) Connection Settings was never opened but the Schema Import ran successfully, in a way that new models may
# convert a db/schema LADM-COL compliant.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in two cases:
# 1) If the SI dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
# 2) Not opening the Connection Settings, but running a successful Schema Import on the COLLECTED DB, which
# invalidates the cache as models change.
self._schedule_layers_and_relations_refresh = False
self.setupUi(self)
self.validators = Validators()
self.update_import_models()
self.previous_item = QListWidgetItem()
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportSchema",
"Connection Settings"))
# CRS Setting
self.srs_auth = DEFAULT_SRS_AUTH
self.srs_code = DEFAULT_SRS_CODE
self.crsSelector.crsChanged.connect(self.crs_changed)
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportSchema", "Show log"))
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_schema)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_CREATE_STRUCTURE, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.import_models_list_widget.setDisabled(bool(
selected_models)) # If we got models from params, disable panel
self.update_connection_info()
self.restore_configuration()
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
def __init__(self, parent, db_action_type):
DbConfigPanel.__init__(self, parent, db_action_type)
lbl_host = QLabel(self.tr("Host"))
lbl_port = QLabel(self.tr("Port"))
lbl_database = QLabel(self.tr("Database"))
lbl_schema = QLabel(self.tr("Schema"))
lbl_user = QLabel(self.tr("User"))
lbl_password = QLabel(self.tr("Password"))
self.pg_host_line_edit = QLineEdit()
self.pg_host_line_edit.setPlaceholderText(self.tr("Database Hostname"))
self.pg_host_line_edit.setText('localhost')
self.pg_port_line_edit = QLineEdit()
self.pg_port_line_edit.setPlaceholderText(
self.tr("[Leave empty to use standard port 5432]"))
self.pg_database_line_edit = QLineEdit()
self.pg_database_line_edit.setPlaceholderText(self.tr("Database Name"))
self.pg_schema_line_edit = QLineEdit()
self.pg_schema_line_edit.setPlaceholderText(
self.tr("[Leave empty to load all schemas in the database]"))
self.pg_user_line_edit = QLineEdit()
self.pg_user_line_edit.setPlaceholderText(self.tr("Database Username"))
self.pg_password_line_edit = QLineEdit()
self.pg_password_line_edit.setEchoMode(QLineEdit.Password)
self.pg_password_line_edit.setPlaceholderText(
self.tr("[Leave empty to use system password]"))
from QgisModelBaker.libili2db.ili2dbconfig import BaseConfiguration
if self._db_action_type != DbActionType.EXPORT:
self.pg_use_super_login = QCheckBox()
self.pg_use_super_login.setText(
self.tr(
"Generate schema with superuser login from settings ({})").
format(BaseConfiguration().super_pg_user))
layout = QGridLayout(self)
layout.addWidget(lbl_host, 0, 0)
layout.addWidget(lbl_port, 1, 0)
layout.addWidget(lbl_database, 2, 0)
layout.addWidget(lbl_schema, 3, 0)
layout.addWidget(lbl_user, 4, 0)
layout.addWidget(lbl_password, 5, 0)
layout.addWidget(self.pg_host_line_edit, 0, 1)
layout.addWidget(self.pg_port_line_edit, 1, 1)
layout.addWidget(self.pg_database_line_edit, 2, 1)
layout.addWidget(self.pg_schema_line_edit, 3, 1)
layout.addWidget(self.pg_user_line_edit, 4, 1)
layout.addWidget(self.pg_password_line_edit, 5, 1)
if self._db_action_type != DbActionType.EXPORT:
layout.addWidget(self.pg_use_super_login, 6, 1)
# define validators
self.validators = Validators()
nonEmptyValidator = NonEmptyStringValidator()
self.pg_host_line_edit.setValidator(nonEmptyValidator)
self.pg_database_line_edit.setValidator(nonEmptyValidator)
self.pg_user_line_edit.setValidator(nonEmptyValidator)
self.pg_host_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.pg_host_line_edit.textChanged.emit(self.pg_host_line_edit.text())
self.pg_database_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.pg_database_line_edit.textChanged.emit(
self.pg_database_line_edit.text())
self.pg_user_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.pg_user_line_edit.textChanged.emit(self.pg_user_line_edit.text())
self.pg_host_line_edit.textChanged.connect(self.notify_fields_modified)
self.pg_port_line_edit.textChanged.connect(self.notify_fields_modified)
self.pg_database_line_edit.textChanged.connect(
self.notify_fields_modified)
self.pg_schema_line_edit.textChanged.connect(
self.notify_fields_modified)
self.pg_user_line_edit.textChanged.connect(self.notify_fields_modified)
self.pg_password_line_edit.textChanged.connect(
self.notify_fields_modified)
def __init__(self,
iface,
conn_manager,
context,
link_to_import_schema=True,
parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db_source = context.get_db_sources()[0]
self.link_to_import_schema = link_to_import_schema
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.base_configuration = BaseConfiguration()
self.logger = Logger()
self.app = AppInterface()
self.__ladmcol_models = LADMColModelRegistry()
self.java_dependency = JavaDependency()
self.java_dependency.download_dependency_completed.connect(
self.download_java_complete)
self.java_dependency.download_dependency_progress_changed.connect(
self.download_java_progress_change)
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDBsSupported()
self._running_tool = False
# There may be 1 case where we need to emit a db_connection_changed from the Import Data dialog:
# 1) Connection Settings was opened and the DB conn was changed.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in 1 case:
# 1) If the ID dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
self._schedule_layers_and_relations_refresh = False
# We need bar definition above calling clear_messages
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData", "Open Transfer or Catalog File"),
file_filter=QCoreApplication.translate(
"DialogImportData",
'Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.validators = Validators()
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogImportData",
"[Name of the XTF to be imported]"))
fileValidator = FileValidator(pattern=['*.xtf', '*.itf', '*.xml'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.update_import_models)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# db
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_data)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_IMPORT_DATA, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData", 'Open Transfer or Catalog File'),
file_filter=QCoreApplication.translate(
"DialogImportData",
'Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.validators = Validators()
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogImportData",
"[Name of the XTF to be created]"))
fileValidator = FileValidator(pattern=['*.xtf', '*.itf', '*.xml'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.update_import_models)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# db
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
'Connection Settings'))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogImportData", "Import data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self.type_combo_box.clear()
self.type_combo_box.addItem(
QCoreApplication.translate("DialogImportData",
'PostgreSQL/PostGIS'), 'pg')
self.type_combo_box.addItem(
QCoreApplication.translate("DialogImportData", 'GeoPackage'),
'gpkg')
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.type_changed()
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData", 'Open Transfer or Catalog File'),
file_filter=QCoreApplication.translate(
"DialogImportData",
'Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.validators = Validators()
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogImportData",
"[Name of the XTF to be created]"))
fileValidator = FileValidator(pattern=['*.xtf', '*.itf', '*.xml'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.update_import_models)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# PG
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self.db_connect_label.setText(self.db.dict_conn_params["database"])
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
'Connection Settings'))
# GPKG
self.gpkg_file_line_edit.setPlaceholderText(
QCoreApplication.translate(
"DialogImportData", "[Name of the Geopackage to be created]"))
self.gpkg_file_browse_button.clicked.connect(
make_save_file_selector(self.gpkg_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData",
'Save in GeoPackage database file'),
file_filter=QCoreApplication.translate(
"DialogImportData",
'GeoPackage Database (*.gpkg)'),
extension='.gpkg'))
gpkgFileValidator = FileValidator(pattern='*.gpkg',
allow_non_existing=True)
self.gpkg_file_line_edit.setValidator(gpkgFileValidator)
self.gpkgSaveFileValidator = FileValidator(pattern='*.gpkg',
allow_non_existing=True)
self.gpkgOpenFileValidator = FileValidator(pattern='*.gpkg')
self.gpkg_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.gpkg_file_line_edit.textChanged.emit(
self.gpkg_file_line_edit.text())
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(
QCoreApplication.translate("DialogImportData", "Import data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.setupUi(self)
self.type_combo_box.clear()
self.type_combo_box.addItem(QCoreApplication.translate("DialogImportSchema", "PostgreSQL/PostGIS"), 'pg')
self.type_combo_box.addItem(QCoreApplication.translate("DialogImportSchema", "GeoPackage"), 'gpkg')
self.type_combo_box.setCurrentIndex(
self.type_combo_box.findData(QSettings().value('Asistente-LADM_COL/db_connection_source', 'pg')))
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.type_changed()
self.schema_name_line_edit.setPlaceholderText(QCoreApplication.translate("DialogImportSchema", "[Name of the schema to be created]"))
self.validators = Validators()
# schema name mustn't have special characters
regex = QRegExp("[a-zA-Z0-9_]+")
validator = QRegExpValidator(regex)
self.schema_name_line_edit.setValidator(validator)
self.schema_name_line_edit.setMaxLength(63)
self.schema_name_line_edit.textChanged.connect(self.validators.validate_line_edits_lower_case)
self.schema_name_line_edit.textChanged.emit(self.schema_name_line_edit.text())
self.update_import_models()
self.previous_item = QListWidgetItem()
# PG
self.db_connect_label.setToolTip(self.db.get_display_conn_string())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(QCoreApplication.translate("DialogImportSchema", "Connection Settings"))
if self.type_combo_box.currentData() == 'pg':
self.db_connect_label.setText(self.db.dict_conn_params['database'])
# GPKG
self.gpkg_file_line_edit.setPlaceholderText(QCoreApplication.translate("DialogImportSchema", "[Name of the Geopackage to be created]"))
self.gpkg_file_browse_button.clicked.connect(make_file_selector(self.gpkg_file_line_edit,
title=QCoreApplication.translate("DialogImportSchema", "Open GeoPackage database file"),
file_filter=QCoreApplication.translate("DialogImportSchema", "GeoPackage Database (*.gpkg)")))
gpkgFileValidator = FileValidator(pattern='*.gpkg')
self.gpkg_file_line_edit.setValidator(gpkgFileValidator)
self.gpkgSaveFileValidator = FileValidator(pattern='*.gpkg', allow_non_existing=True)
self.gpkgOpenFileValidator = FileValidator(pattern='*.gpkg')
self.gpkg_file_line_edit.textChanged.connect(self.validators.validate_line_edits)
# LOG
self.log_config.setTitle(QCoreApplication.translate("DialogImportSchema", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(QCoreApplication.translate("DialogImportSchema", "Create LADM-COL structure"), QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
def __init__(self, iface, qgis_utils, conn_manager, context):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.conn_manager = conn_manager
self.db_source = context.get_db_sources()[0]
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.qgis_utils = qgis_utils
self.logger = Logger()
self.java_utils = JavaUtils()
self.java_utils.download_java_completed.connect(
self.download_java_complete)
self.java_utils.download_java_progress_changed.connect(
self.download_java_progress_change)
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._dbs_supported = ConfigDbSupported()
self._running_tool = False
# There may be 1 case where we need to emit a db_connection_changed from the Export Data dialog:
# 1) Connection Settings was opened and the DB conn was changed.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in 1 case:
# 1) If the ED dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
self._schedule_layers_and_relations_refresh = False
# We need bar definition above calling clear_messages
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.xtf_file_browse_button.clicked.connect(
make_save_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"XTF Transfer File (*.xtf);;Interlis 1 Transfer File (*.itf);;XML (*.xml);;GML (*.gml)"
),
extension='.xtf',
extensions=['.' + ext for ext in self.ValidExtensions]))
self.xtf_file_browse_button.clicked.connect(
self.xtf_browser_opened_to_true)
self.xtf_browser_was_opened = False
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions],
allow_non_existing=True)
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogExportData",
"[Name of the XTF to be created]"))
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.connect(
self.xtf_browser_opened_to_false)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogExportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogExportData", "Export data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.update_model_names()
self.restore_configuration()
class QgisModelBakerPlugin(QObject):
def __init__(self, iface):
QObject.__init__(self)
self.iface = iface
self.plugin_dir = os.path.dirname(__file__)
self.__generate_action = None
self.__export_action = None
self.__importdata_action = None
self.__configure_action = None
self.__help_action = None
self.__about_action = None
self.__separator = None
if locale.getlocale() == (None, None):
locale.setlocale(locale.LC_ALL, '')
# initialize translation
qgis_locale_id = str(QSettings().value('locale/userLocale'))
qgis_locale = QLocale(qgis_locale_id)
locale_path = os.path.join(self.plugin_dir, 'i18n')
self.translator = QTranslator()
self.translator.load(qgis_locale, 'QgisModelBaker', '_', locale_path)
QCoreApplication.installTranslator(self.translator)
self.ili2db_configuration = BaseConfiguration()
settings = QSettings()
settings.beginGroup('QgisModelBaker/ili2db')
self.ili2db_configuration.restore(settings)
def initGui(self):
pyplugin_installer.installer.initPluginInstaller()
pyplugin_installer.installer_data.plugins.rebuild()
if 'projectgenerator' in pyplugin_installer.installer_data.plugins.all(
).keys():
import qgis
pyplugin_installer.instance().uninstallPlugin('projectgenerator',
quiet=True)
self.__generate_action = QAction(
QIcon(
os.path.join(os.path.dirname(__file__),
'images/QgisModelBaker-icon.svg')),
self.tr('Generate'), None)
self.__export_action = QAction(
QIcon(
os.path.join(os.path.dirname(__file__),
'images/QgisModelBaker-xtf-export-icon.svg')),
self.tr('Export Interlis Transfer File (.xtf)'), None)
self.__importdata_action = QAction(
QIcon(
os.path.join(os.path.dirname(__file__),
'images/QgisModelBaker-xtf-import-icon.svg')),
self.tr('Import Interlis Transfer File (.xtf)'), None)
self.__configure_action = QAction(self.tr('Settings'), None)
self.__help_action = QAction(self.tr('Help'), None)
self.__about_action = QAction(self.tr('About'), None)
self.__separator = QAction(None)
self.__separator.setSeparator(True)
self.__generate_action.triggered.connect(self.show_generate_dialog)
self.__configure_action.triggered.connect(self.show_options_dialog)
self.__importdata_action.triggered.connect(self.show_importdata_dialog)
self.__export_action.triggered.connect(self.show_export_dialog)
self.__help_action.triggered.connect(self.show_help_documentation)
self.__about_action.triggered.connect(self.show_about_dialog)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__generate_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__importdata_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__export_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__configure_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__separator)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__help_action)
self.iface.addPluginToDatabaseMenu(self.tr('Model Baker'),
self.__about_action)
self.toolbar = self.iface.addToolBar(self.tr('Model Baker'))
self.toolbar.setObjectName("ModelBakerToolbar")
self.toolbar.setToolTip(self.tr('Model Baker Toolbar'))
self.toolbar.addAction(self.__generate_action)
self.toolbar.addAction(self.__importdata_action)
self.toolbar.addAction(self.__export_action)
def unload(self):
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__generate_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__importdata_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__export_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__configure_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__help_action)
self.iface.removePluginDatabaseMenu(self.tr('Model Baker'),
self.__about_action)
del self.__generate_action
del self.__export_action
del self.__importdata_action
del self.__configure_action
del self.__help_action
del self.__about_action
def show_generate_dialog(self):
dlg = GenerateProjectDialog(self.iface, self.ili2db_configuration)
dlg.exec_()
def show_options_dialog(self):
dlg = OptionsDialog(self.ili2db_configuration)
if dlg.exec_():
settings = QSettings()
settings.beginGroup('QgisModelBaker/ili2db')
self.ili2db_configuration.save(settings)
def show_export_dialog(self):
dlg = ExportDialog(self.ili2db_configuration)
dlg.exec_()
def show_importdata_dialog(self):
dlg = ImportDataDialog(self.ili2db_configuration)
dlg.exec_()
def show_help_documentation(self):
os_language = QLocale(
QSettings().value('locale/userLocale')).name()[:2]
if os_language in ['es', 'de']:
webbrowser.open(
'https://opengisch.github.io/QgisModelBaker/docs/{}/'.format(
os_language))
else:
webbrowser.open(
'https://opengisch.github.io/QgisModelBaker/docs/index.html')
def show_about_dialog(self):
self.msg = QMessageBox()
self.msg.setIcon(QMessageBox.Information)
self.msg.setTextFormat(Qt.RichText)
self.msg.setWindowTitle(self.tr('About Model Baker'))
self.msg.setText(
self.tr("""<h1>Model Baker</h1>
<p align="justify">Configuring QGIS layers and forms manually is a tedious and error prone process. This plugin loads database schemas with various meta
information to preconfigure the layer tree, widget configuration, relations and more.</p>
<p align="justify">This project is open source under the terms of the GPLv2 or later and the source code can be found on <a href="https://github.com/opengisch/QgisModelBaker">github</a>.</p>
<p align="justify">This plugin is developed by <a href="https://www.opengis.ch/">OPENGIS.ch</a> in collaboration with
<a href="https://www.proadmintierra.info/">Agencia de Implementación (BSF-Swissphoto AG / INCIGE S.A.S.)</a>.</p></p>"""
))
self.msg.setStandardButtons(QMessageBox.Close)
msg_box = self.msg.exec_()
def get_generator(self):
return Generator
def create_project(self,
layers,
relations,
bags_of_enum,
legend,
auto_transaction=True,
evaluate_default_values=True):
"""
Expose the main functionality from Model Baker to other plugins,
namely, create a QGIS project from objects obtained from the Generator
class.
:param layers: layers object from generator.layers
:param relations: relations object obtained from generator.relations
:param bags_of_enum: bags_of_enum object from generator.relations
:param legend: legend object obtained from generator.legend
:param auto_transaction: whether transactions should be enabled or not
when editing layers from supported DB like PG
:param evaluate_default_values: should default values be evaluated on
provider side when requested and not
when committed. (from QGIS docs)
"""
project = Project(auto_transaction, evaluate_default_values)
project.layers = layers
project.relations = relations
project.bags_of_enum = bags_of_enum
project.legend = legend
project.post_generate()
qgis_project = QgsProject.instance()
project.create(None, qgis_project)
