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)