def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale_str = QSettings().value('locale/userLocale')
if isinstance(locale_str, str):
locale = QLocale(locale_str)
else:
locale = QLocale()
locale_path = os.path.join(self.plugin_dir, 'i18n')
self.translator = QTranslator()
self.translator.load(locale, 'qfieldsync', '_', locale_path)
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = self.tr('&QFieldSync')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar('QFieldSync')
self.toolbar.setObjectName('QFieldSync')
# instance of the map config widget factory, shown in layer properties
self.mapLayerConfigWidgetFactory = MapLayerConfigWidgetFactory('QField', QIcon(os.path.join(os.path.dirname(__file__), 'resources/icon.png')))
# instance of the QgsOfflineEditing
self.offline_editing = QgsOfflineEditing()
self.preferences = Preferences()
QgsProject.instance().readProject.connect(self.update_button_enabled_status)
# store warnings from last run
self.last_action_warnings = []
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_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 setUpClass(cls):
"""Run before all tests"""
QCoreApplication.setOrganizationName("QGIS_Test")
QCoreApplication.setOrganizationDomain(
"QGIS_TestQgsDateTimeFieldFormatter.com")
QCoreApplication.setApplicationName(
"QGIS_TestQgsDateTimeFieldFormatter")
QgsSettings().clear()
QLocale.setDefault(QLocale(QLocale.English))
start_app()
def test_displayString(self):
"""Test the displayString method"""
# Default locale for tests is EN
original_locale = QLocale()
locale = QLocale(QLocale.English)
locale.setNumberOptions(QLocale.DefaultNumberOptions)
QLocale().setDefault(locale)
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234.56), "1,234.56")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234.56, 4), "1,234.5600")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234567), "1,234,567")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234567.0, 4), "1,234,567.0000")
# Precision is ignored for integers
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234567, 4), "1,234,567")
# Test list
self.assertEqual(QgsCategorizedSymbolRenderer.displayString([1234567, 891234], 4), "1,234,567;891,234")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString([1234567.123, 891234.123], 4), "1,234,567.1230;891,234.1230")
locale.setNumberOptions(QLocale.OmitGroupSeparator)
QLocale().setDefault(locale)
self.assertTrue(QLocale().numberOptions() & QLocale.OmitGroupSeparator)
self.assertEqual(QgsCategorizedSymbolRenderer.displayString([1234567, 891234], 4), "1234567;891234")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString([1234567.123, 891234.123], 4), "1234567.1230;891234.1230")
# Test a non-dot locale
locale = QLocale(QLocale.Italian)
locale.setNumberOptions(QLocale.DefaultNumberOptions)
QLocale().setDefault(locale)
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234.56), "1.234,56")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234.56, 4), "1.234,5600")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234567), "1.234.567")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234567.0, 4), "1.234.567,0000")
# Precision is ignored for integers
self.assertEqual(QgsCategorizedSymbolRenderer.displayString(1234567, 4), "1.234.567")
# Test list
self.assertEqual(QgsCategorizedSymbolRenderer.displayString([1234567, 891234], 4), "1.234.567;891.234")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString([1234567.123, 891234.123], 4), "1.234.567,1230;891.234,1230")
locale.setNumberOptions(QLocale.OmitGroupSeparator)
QLocale().setDefault(locale)
self.assertEqual(QgsCategorizedSymbolRenderer.displayString([1234567, 891234], 4), "1234567;891234")
self.assertEqual(QgsCategorizedSymbolRenderer.displayString([1234567.123, 891234.123], 4), "1234567,1230;891234,1230")
QLocale().setDefault(original_locale)
def help_requested(self):
os_language = QLocale(
QSettings().value("locale/userLocale")).name()[:2]
if os_language in ["es", "de"]:
webbrowser.open(
"https://opengisch.github.io/QgisModelBaker/docs/{}/user-guide.html#export-an-interlis-transfer-file-xtf"
.format(os_language))
else:
webbrowser.open(
"https://opengisch.github.io/QgisModelBaker/docs/user-guide.html#export-an-interlis-transfer-file-xtf"
)
def help_requested(self):
os_language = QLocale(
QSettings().value('locale/userLocale')).name()[:2]
if os_language in ['es', 'de']:
webbrowser.open(
"https://opengisch.github.io/projectgenerator/docs/{}/user-guide.html#generate-project"
.format(os_language))
else:
webbrowser.open(
"https://opengisch.github.io/projectgenerator/docs/user-guide.html#generate-project"
)
def help_requested(self):
os_language = QLocale(
QSettings().value('locale/userLocale')).name()[:2]
if os_language in ['es', 'de']:
webbrowser.open(
"https://opengisch.github.io/QgisModelBaker/docs/{}/user-guide.html#plugin-configuration"
.format(os_language))
else:
webbrowser.open(
"https://opengisch.github.io/QgisModelBaker/docs/user-guide.html#plugin-configuration"
)
def open_help(self):
""" Open the online documentation for the panel. """
locale = QgsSettings().value("locale/userLocale", QLocale().name())
locale = locale[0:2]
if locale not in ONLINE_HELP_LANGUAGES:
locale = 'en'
url = '{url}/{lang}/{page}'.format(url=DOC_URL,
lang=locale,
page=self.config.help())
QDesktopServices.openUrl(QUrl(url))
def testExportFeaturesWithLocale_regression20053(self):
""" Test exporting feature export with range widgets and locale different than C
Regression: https://issues.qgis.org/issues/20053 - decimal separator in csv files
"""
source = QgsVectorLayer(
"Point?field=name:string&field=cost:double&field=population:int&field=date:date",
"parent", "memory")
self.assertTrue(source.isValid())
fields = source.fields()
feature = QgsFeature(fields, 5)
feature.setGeometry(QgsGeometry(QgsPoint(5, 6)))
feature.setAttributes(['Valsier Peninsula', 6.8, 198000, '2018-09-10'])
exporter = QgsJsonExporter()
# single feature
expected = """{ "type": "FeatureCollection",
"features":[
{
"type":"Feature",
"id":5,
"geometry":
{"type": "Point", "coordinates": [5, 6]},
"properties":{
"name":"Valsier Peninsula",
"cost":6.8,
"population":198000,
"date":"2018-09-10"
}
}
]}"""
self.assertEqual(exporter.exportFeatures([feature]), expected)
setup = QgsEditorWidgetSetup(
'Range', {
'AllowNull': True,
'Max': 2147483647,
'Min': -2147483648,
'Precision': 4,
'Step': 1,
'Style': 'SpinBox'
})
source.setEditorWidgetSetup(1, setup)
source.setEditorWidgetSetup(2, setup)
QLocale.setDefault(QLocale('it'))
exporter.setVectorLayer(source)
self.assertEqual(exporter.exportFeatures([feature]), expected)
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 carregaIdioma(self, app, idioma='ca'):
if app is None:
return
self.appQgis = app
self.idioma = self.paramCfg('Idioma', idioma)
self.qtTranslator = QTranslator()
self.qgisTranslator = QTranslator()
path = QLibraryInfo.location(QLibraryInfo.TranslationsPath)
self.qtTranslator.load("qt_" + idioma, path)
app.installTranslator(self.qtTranslator)
path = app.i18nPath()
path = path.replace('/./', '/')
self.qgisTranslator.load("qgis_" + idioma, path)
app.installTranslator(self.qgisTranslator)
self.locale = QLocale(self.idioma + "-ES")
def testQgsClassificationLogarithmic(self):
values = [
2746.71, 66667.49, 77282.52, 986567.01, 1729508.41, 9957836.86,
35419826.29, 52584164.80, 296572842.00
]
vl = createMemoryLayer(values)
m = QgsClassificationLogarithmic()
r = m.classes(vl, 'value', 8)
self.assertEqual(len(r), 6)
self.assertEqual(r[0].label(),
'{} - 10^4'.format(QLocale().toString(2746.71)))
self.assertEqual(QgsClassificationMethod.rangesToBreaks(r), [
10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0
])
self.assertEqual(len(m.classes(vl, 'value', 4)), 4)
def test_localizedCategories(self):
# Default locale for tests is EN
original_locale = QLocale()
locale = QLocale(QLocale.English)
locale.setNumberOptions(QLocale.DefaultNumberOptions)
QLocale().setDefault(locale)
layer = QgsVectorLayer(
"Point?field=flddbl:double&field=fldint:integer", "addfeat",
"memory")
result = QgsCategorizedSymbolRenderer.createCategories(
[1234.5, 2345.6, 3456.7], QgsMarkerSymbol(), layer, 'flddouble')
self.assertEqual(result[0].label(), '1,234.5')
self.assertEqual(result[1].label(), '2,345.6')
self.assertEqual(result[2].label(), '3,456.7')
# Test a non-dot locale
QLocale().setDefault(QLocale(QLocale.Italian))
result = QgsCategorizedSymbolRenderer.createCategories(
[[1234.5, 6789.1], 2345.6, 3456.7], QgsMarkerSymbol(), layer,
'flddouble')
self.assertEqual(result[0].label(), '1.234,5;6.789,1')
self.assertEqual(result[1].label(), '2.345,6')
self.assertEqual(result[2].label(), '3.456,7')
# Test round trip
temp_dir = QTemporaryDir()
temp_file = os.path.join(temp_dir.path(), 'project.qgs')
project = QgsProject()
layer.setRenderer(QgsCategorizedSymbolRenderer('Class', result))
project.addMapLayers([layer])
project.write(temp_file)
QLocale().setDefault(original_locale)
project = QgsProject()
project.read(temp_file)
results = project.mapLayersByName('addfeat')[0].renderer().categories()
self.assertEqual(result[0].label(), '1.234,5;6.789,1')
self.assertEqual(result[1].label(), '2.345,6')
self.assertEqual(result[2].label(), '3.456,7')
self.assertEqual(result[0].value(), [1234.5, 6789.1])
self.assertEqual(result[1].value(), 2345.6)
self.assertEqual(result[2].value(), 3456.7)
def __init__(self, parent=None, data=None):
"""
Constructor
Creates the dialog, connect events
"""
super().__init__()
self.ui = Ui_Settings()
self.ui.setupUi(self)
self.api = data["api"]
metadata = get_plugin_metadata()
# "Picterra account" tab
self.ui.api_key_text.setText(get_setting("api_key"))
self.ui.api_server_text.setText(urlparse(get_api_server()).netloc)
try:
if self.api.ping() == 200:
self.ui.nr_rasters.setText(str(len(self.api.get_rasters())))
self.ui.nr_detectors.setText(str(len(
self.api.get_detectors())))
except ApiError as e:
logger.error(str(e))
self.ui.nr_rasters.setText(tr("N/A"))
self.ui.nr_detectors.setText(tr("N/A"))
# "QGIS settings" tab
self.ui.locale_text.setText(str(QLocale().name()))
self.ui.sw_version_text.setText(str(Qgis.QGIS_VERSION))
self.ui.plugin_category_text.setText(str(metadata["category"]))
self.ui.plugin_version_text.setText(str(metadata["version"]))
# Rejected-close connection is already in the .ui files
self.ui.button_box_picterra.button(
QDialogButtonBox.Apply).clicked.connect(self.save_settings)
self.ui.button_box_qgis.button(QDialogButtonBox.Apply).clicked.connect(
self.save_settings)
self.ui.button_box_picterra.button(
QDialogButtonBox.RestoreDefaults).clicked.connect(
self.restore_settings)
self.ui.button_box_qgis.button(
QDialogButtonBox.RestoreDefaults).clicked.connect(
self.restore_settings)
def showPluginDoc(
packageName: Optional[str] = None, filename: str = "index", section: str = ""
) -> None:
"""
Shows a help in the user's html browser.
The help file should be named index-ll_CC.html or index-ll.html
"""
if get_debug_flag():
helpfile = os.path.dirname(__file__) + "/help/build/html/index.html"
else:
source = ""
if packageName is None:
import inspect
source = inspect.currentframe().f_back.f_code.co_filename # type: ignore
else:
source = sys.modules[packageName].__file__
path = os.path.dirname(source)
locale = str(QLocale().name())
helpfile = os.path.join(path, filename + "-" + locale + ".html")
if not os.path.exists(helpfile):
helpfile = os.path.join(
path,
filename + "-" + locale.split("_")[0] + ".html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + "-en.html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + "-en_US.html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + ".html")
if os.path.exists(helpfile):
url = "file://" + helpfile
if section != "":
url = url + "#" + section
QDesktopServices.openUrl(QUrl(url))
else:
logger = Logger(__file__)
logger.error("No file %s" % helpfile)
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 test_representValueWithDefault(self):
"""
Check representValue behaves correctly when used on a layer which define default values
"""
dbname = os.path.join(tempfile.mkdtemp(), 'test.sqlite')
con = spatialite_connect(dbname, isolation_level=None)
cur = con.cursor()
cur.execute("BEGIN")
sql = """
CREATE TABLE test_table_default_values (
id integer primary key autoincrement,
anumber INTEGER DEFAULT 123
)
"""
cur.execute(sql)
cur.execute("COMMIT")
con.close()
vl = QgsVectorLayer(dbname + '|layername=test_table_default_values',
'test_table_default_values', 'ogr')
self.assertTrue(vl.isValid())
fieldFormatter = QgsFallbackFieldFormatter()
QLocale.setDefault(QLocale('en'))
self.assertEqual(
fieldFormatter.representValue(vl, 1, {}, None,
QVariant(QVariant.Int)), 'NULL')
self.assertEqual(fieldFormatter.representValue(vl, 1, {}, None, 4),
'4')
self.assertEqual(fieldFormatter.representValue(vl, 1, {}, None, "123"),
'123')
# bad field index
self.assertEqual(fieldFormatter.representValue(vl, 3, {}, None, 5), "")
def showPluginHelp(packageName: str = None,
filename: str = "index",
section: str = ""):
"""Open help in the user's html browser. The help file should be named index-ll_CC.html or index-ll.html or index.html.
:param str packageName: name of package folder, if None it's using the current file package. Defaults to None. Optional.
:param str filename: name of file to open. It can be a path like 'doc/index' for example. Defaults to 'index'.
:param str section: URL path to open. Defaults to empty string.
"""
try:
source = ""
if packageName is None:
import inspect
source = inspect.currentframe().f_back.f_code.co_filename
else:
source = sys.modules[packageName].__file__
except:
return
path = os.path.dirname(source)
locale = str(QLocale().name())
helpfile = os.path.join(path, filename + "-" + locale + ".html")
if not os.path.exists(helpfile):
helpfile = os.path.join(
path, filename + "-" + locale.split("_")[0] + ".html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + "-en.html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + "-en_US.html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + ".html")
if os.path.exists(helpfile):
url = "file://" + helpfile
if section != "":
url = url + "#" + section
QDesktopServices.openUrl(QUrl(url))
def _test(layer, is_gpkg=False):
# Skip fid and precision tests
offset = 1 if is_gpkg else 0
fieldFormatter = QgsFallbackFieldFormatter()
QLocale.setDefault(QLocale('en'))
# Precision is ignored for integers and longlongs
self.assertEqual(fieldFormatter.representValue(layer, 0 + offset, {}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 0 + offset, {}, None, '123000'), '123,000')
self.assertEqual(fieldFormatter.representValue(layer, 0 + offset, {}, None, '9999999'), '9,999,999')
self.assertEqual(fieldFormatter.representValue(layer, 0 + offset, {}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, '123000'), '123,000')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, '9999999'), '9,999,999')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, None), 'NULL')
if not is_gpkg:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123'), '123.00000')
else:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, None), 'NULL')
if not is_gpkg:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123000'), '123,000.00000')
else:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123000'), '123,000')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '0'), '0')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '0.127'), '0.127')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '1.27e-1'), '0.127')
if not is_gpkg:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '-123'), '-123.00000')
else:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '-123'), '-123')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '-0.127'), '-0.127')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '-1.27e-1'), '-0.127')
# Check with Italian locale
QLocale.setDefault(QLocale('it'))
self.assertEqual(fieldFormatter.representValue(layer, 0 + offset, {}, None, '9999999'),
'9.999.999') # scientific notation for integers!
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, '123000'), '123.000')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, '9999999'), '9.999.999')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, None), 'NULL')
if not is_gpkg:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123000'), '123.000,00000')
else:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123000'), '123.000')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '0'), '0')
if not is_gpkg:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123'), '123,00000')
else:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '0.127'), '0,127')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '1.27e-1'), '0,127')
if not is_gpkg:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '-123'), '-123,00000')
else:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '-123'), '-123')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '-0.127'), '-0,127')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '-1.27e-1'), '-0,127')
# Check with custom locale without thousand separator
custom = QLocale('en')
custom.setNumberOptions(QLocale.OmitGroupSeparator)
QLocale.setDefault(custom)
self.assertEqual(fieldFormatter.representValue(layer, 0 + offset, {}, None, '9999999'),
'9999999') # scientific notation for integers!
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, '9999999'), '9999999')
if not is_gpkg:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123000'), '123000.00000')
else:
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, '123000'), '123000')
# Check string
self.assertEqual(fieldFormatter.representValue(layer, 3 + offset, {}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 3 + offset, {}, None, 'a string'), 'a string')
self.assertEqual(fieldFormatter.representValue(layer, 3 + offset, {}, None, ''), '')
self.assertEqual(fieldFormatter.representValue(layer, 3 + offset, {}, None, None), 'NULL')
# Check NULLs (this is what happens in real life inside QGIS)
self.assertEqual(fieldFormatter.representValue(layer, 0 + offset, {}, None, QVariant(QVariant.String)),
'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 1 + offset, {}, None, QVariant(QVariant.String)),
'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 2 + offset, {}, None, QVariant(QVariant.String)),
'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 3 + offset, {}, None, QVariant(QVariant.String)),
'NULL')
def test_representValue(self):
layer = QgsVectorLayer("point?field=int:integer&field=double:double&field=long:long",
"layer", "memory")
self.assertTrue(layer.isValid())
QgsProject.instance().addMapLayers([layer])
fieldFormatter = QgsRangeFieldFormatter()
# Precision is ignored for integers and longlongs
self.assertEqual(fieldFormatter.representValue(layer, 0, {'Precision': 1}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 0, {'Precision': 1}, None, '123000'), '123,000')
self.assertEqual(fieldFormatter.representValue(layer, 0, {'Precision': 1}, None, '9999999'), '9,999,999') # no scientific notation for integers!
self.assertEqual(fieldFormatter.representValue(layer, 0, {'Precision': 1}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '123000'), '123,000')
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '9999999'), '9,999,999') # no scientific notation for long longs!
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 1}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 1}, None, '123'), '123.0')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '123000'), '123,000.00')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '0'), '0.00')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '123'), '123.00')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '0.123'), '0.12')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '0.127'), '0.13')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '0'), '0.000')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '0.127'), '0.127')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '1.27e-1'), '0.127')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '-123'), '-123.00')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '-0.123'), '-0.12')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '-0.127'), '-0.13')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '-0.127'), '-0.127')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '-1.27e-1'), '-0.127')
# Check with Italian locale
QLocale.setDefault(QLocale('it'))
self.assertEqual(fieldFormatter.representValue(layer, 0, {'Precision': 1}, None, '9999999'),
'9.999.999') # scientific notation for integers!
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '123000'), '123.000')
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '9999999'), '9.999.999') # scientific notation for long longs!
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, None), 'NULL')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '123000'), '123.000,00')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '0'), '0,00')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '123'), '123,00')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '0.123'), '0,12')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '0.127'), '0,13')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '0'), '0,000')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '0.127'), '0,127')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '1.27e-1'), '0,127')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '-123'), '-123,00')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '-0.123'), '-0,12')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '-0.127'), '-0,13')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '-0.127'), '-0,127')
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 3}, None, '-1.27e-1'), '-0,127')
# Check with custom locale without thousand separator
custom = QLocale('en')
custom.setNumberOptions(QLocale.OmitGroupSeparator)
QLocale.setDefault(custom)
self.assertEqual(fieldFormatter.representValue(layer, 0, {'Precision': 1}, None, '9999999'),
'9999999') # scientific notation for integers!
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '123'), '123')
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '123000'), '123000')
self.assertEqual(fieldFormatter.representValue(layer, 2, {'Precision': 1}, None, '9999999'), '9999999') # scientific notation for long longs!
self.assertEqual(fieldFormatter.representValue(layer, 1, {'Precision': 2}, None, '123000'), '123000.00')
QgsProject.instance().removeAllMapLayers()
def tearDownClass(cls):
"""Reset locale"""
QLocale.setDefault(QLocale(QLocale.English))
def _fld_checker(self, field):
"""
Expected results from validate
QValidator::Invalid 0 The string is clearly invalid.
QValidator::Intermediate 1 The string is a plausible intermediate value.
QValidator::Acceptable 2 The string is acceptable as a final result; i.e. it is valid.
"""
DECIMAL_SEPARATOR = QLocale().decimalPoint()
OTHER_SEPARATOR = ',' if DECIMAL_SEPARATOR == '.' else '.'
validator = QgsFieldValidator(None, field, '0.0', '')
def _test(value, expected):
ret = validator.validate(value, 0)
self.assertEqual(ret[0], expected, "%s != %s" % (ret[0], expected))
if value:
self.assertEqual(validator.validate('-' + value, 0)[0], expected, '-' + value)
# Valid
_test('0.1234', QValidator.Acceptable)
# Apparently we accept comma only when locale say so
if DECIMAL_SEPARATOR != '.':
_test('0,1234', QValidator.Acceptable)
# If precision is > 0, regexp validator is used (and it does not support sci notation)
if field.precision() == 0:
_test('12345.1234e+123', QValidator.Acceptable)
_test('12345.1234e-123', QValidator.Acceptable)
if DECIMAL_SEPARATOR != '.':
_test('12345,1234e+123', QValidator.Acceptable)
_test('12345,1234e-123', QValidator.Acceptable)
_test('', QValidator.Acceptable)
# Out of range
_test('12345.1234e+823', QValidator.Intermediate)
_test('12345.1234e-823', QValidator.Intermediate)
if DECIMAL_SEPARATOR != '.':
_test('12345,1234e+823', QValidator.Intermediate)
_test('12345,1234e-823', QValidator.Intermediate)
# Invalid
_test('12345-1234', QValidator.Invalid)
_test('onetwothree', QValidator.Invalid)
int_field = self.vl.fields()[self.vl.fields().indexFromName('int_field')]
self.assertEqual(int_field.precision(), 0) # this is what the provider reports :(
self.assertEqual(int_field.length(), 0) # not set
self.assertEqual(int_field.type(), QVariant.Int)
validator = QgsFieldValidator(None, int_field, '0', '')
# Valid
_test('0', QValidator.Acceptable)
_test('1234', QValidator.Acceptable)
_test('', QValidator.Acceptable)
# Invalid
_test('12345-1234', QValidator.Invalid)
_test('12345%s1234' % DECIMAL_SEPARATOR, QValidator.Invalid)
_test('onetwothree', QValidator.Invalid)
def test_doubleValidatorDotLocale(self):
"""Test the double with english locale"""
QLocale.setDefault(QLocale(QLocale.English))
assert QLocale().decimalPoint() == '.'
field = self.vl.fields()[self.vl.fields().indexFromName('double_field')]
self._fld_checker(field)
def test_doubleValidatorCommaLocale(self):
"""Test the double with german locale"""
QLocale.setDefault(QLocale(QLocale.German, QLocale.Germany))
assert QLocale().decimalPoint() == ','
field = self.vl.fields()[self.vl.fields().indexFromName('double_field')]
self._fld_checker(field)
return LDMPPlugin(iface)
# Function to get a temporary filename that handles closing the file created by
# NamedTemporaryFile - necessary when the file is for usage in another process
# (i.e. GDAL)
def GetTempFilename(suffix):
f = NamedTemporaryFile(suffix=suffix, delete=False)
f.close()
return f.name
# initialize translation
i18n_dir = os.path.join(plugin_dir, 'i18n')
log(u'Starting trends.earth version {} (rev: {}, released {}).'.format(__version__, __revision__, __release_date__))
translator = QTranslator()
locale = QLocale(QgsApplication.locale())
log('Trying to load locale {} from {}.'.format(locale.name(), i18n_dir))
translator.load(locale, 'LDMP', prefix='.', directory=i18n_dir, suffix='.qm')
ret = QCoreApplication.installTranslator(translator)
if ret:
log("Translator installed for {}.".format(locale.name()))
else:
log("FAILED while trying to install translator for {}.".format(locale.name()))
# Ensure that the ext-libs, and binaries folder (if available) are near the
# front of the path (important on Linux)
ext_libs_path = os.path.join(plugin_dir, 'ext-libs')
binaries_folder = QSettings().value("LDMP/binaries_folder", None)
sys.path, remainder = sys.path[:1], sys.path[1:]
site.addsitedir(ext_libs_path)
if binaries_folder:
import os.path
from qgis.PyQt.QtCore import (QLocale,
QSettings,
QCoreApplication,
QTranslator)
DEFAULT_LANGUAGE = 'en'
try:
# Errors here could happen if the value cannot be converted to string or
# if it is not subscriptable (see https://github.com/gacarrillor/loadthemall/issues/11)
locale = QSettings().value("locale/userLocale", type=str)
QGIS_LANG = str( locale[:2] )
except TypeError as e:
QGIS_LANG = DEFAULT_LANGUAGE
PLUGIN_DIR = os.path.dirname(os.path.dirname(__file__))
# Install Qt Translator
qgis_locale = QLocale(QGIS_LANG)
locale_path = os.path.join(PLUGIN_DIR, 'i18n')
translator = QTranslator()
translator.load(qgis_locale, 'Asistente-LADM_COL', '_', locale_path)
QCoreApplication.installTranslator(translator)
def layers(self, filter_layer_list=[]):
tables_info = self.get_tables_info_without_ignored_tables()
basket_handling = self.get_basket_handling()
layers = list()
db_factory = self.db_simple_factory.create_factory(self.tool)
layer_uri = db_factory.get_layer_uri(self.uri)
layer_uri.pg_estimated_metadata = self.pg_estimated_metadata
# When a table has multiple geometry columns, it will be loaded multiple times (supported e.g. by PostGIS).
table_appearance_count = {}
for record in tables_info:
if self.schema:
if record["schemaname"] != self.schema:
continue
if filter_layer_list and record[
"tablename"] not in filter_layer_list:
continue
table_appearance_count[record["tablename"]] = (
table_appearance_count.get(record["tablename"], 0) + 1)
for record in tables_info:
# When in PostGIS mode, leaving schema blank should load tables from
# all schemas, except the ignored ones
if self.schema:
if record["schemaname"] != self.schema:
continue
if filter_layer_list and record[
"tablename"] not in filter_layer_list:
continue
is_domain = (record.get("kind_settings") == "ENUM"
or record.get("kind_settings") == "CATALOGUE")
is_attribute = bool(record.get("attribute_name"))
is_structure = record.get("kind_settings") == "STRUCTURE"
is_nmrel = record.get("kind_settings") == "ASSOCIATION"
is_basket_table = (record.get("tablename") ==
self._db_connector.basket_table_name)
is_dataset_table = (record.get("tablename") ==
self._db_connector.dataset_table_name)
alias = record["table_alias"] if "table_alias" in record else None
if not alias:
short_name = None
if is_domain and is_attribute:
short_name = ""
if "ili_name" in record and record["ili_name"]:
short_name = (record["ili_name"].split(".")[-2] + "_" +
record["ili_name"].split(".")[-1])
else:
if (table_appearance_count[record["tablename"]] > 1
and "geometry_column" in record):
# multiple layers for this table - append geometry column to name
fields_info = self.get_fields_info(record["tablename"])
for field_info in fields_info:
if field_info["column_name"] == record[
"geometry_column"]:
if ("fully_qualified_name" in field_info and
field_info["fully_qualified_name"]):
short_name = (
field_info["fully_qualified_name"].
split(".")[-2] + " (" +
field_info["fully_qualified_name"].
split(".")[-1] + ")")
else:
short_name = record["tablename"]
elif "ili_name" in record and record["ili_name"]:
match = re.search(r"([^\(]*).*", record["ili_name"])
if match.group(0) == match.group(1):
short_name = match.group(1).split(".")[-1]
else:
# additional brackets in the the name - extended layer in geopackage
short_name = (match.group(1).split(".")[-2] +
" (" +
match.group(1).split(".")[-1] + ")")
alias = short_name
model_topic_name = ""
if "ili_name" in record and record["ili_name"]:
if record["ili_name"].count(".") > 1:
model_topic_name = f"{record['ili_name'].split('.')[0]}.{record['ili_name'].split('.')[1]}"
display_expression = ""
if is_basket_table:
display_expression = "coalesce(attribute(get_feature('{dataset_layer_name}', '{tid}', dataset), 'datasetname') || ' (' || topic || ') ', coalesce( attribute(get_feature('{dataset_layer_name}', '{tid}', dataset), 'datasetname'), {tilitid}))".format(
tid=self._db_connector.tid,
tilitid=self._db_connector.tilitid,
dataset_layer_name=self._db_connector.dataset_table_name,
)
elif "ili_name" in record and record["ili_name"]:
meta_attrs = self.get_meta_attrs(record["ili_name"])
for attr_record in meta_attrs:
if attr_record["attr_name"] == "dispExpression":
display_expression = attr_record["attr_value"]
coord_decimals = (record["coord_decimals"]
if "coord_decimals" in record else None)
coordinate_precision = None
if coord_decimals:
coordinate_precision = 1 / (10**coord_decimals)
layer = Layer(
layer_uri.provider,
layer_uri.get_data_source_uri(record),
record["tablename"],
record["srid"],
record["extent"] if "extent" in record else None,
record["geometry_column"],
QgsWkbTypes.parseType(record["type"]) or QgsWkbTypes.Unknown,
alias,
is_domain,
is_structure,
is_nmrel,
display_expression,
coordinate_precision,
is_basket_table,
is_dataset_table,
model_topic_name,
)
# Configure fields for current table
fields_info = self.get_fields_info(record["tablename"])
min_max_info = self.get_min_max_info(record["tablename"])
value_map_info = self.get_value_map_info(record["tablename"])
re_iliname = re.compile(r".*\.(.*)$")
for fielddef in fields_info:
column_name = fielddef["column_name"]
fully_qualified_name = (fielddef["fully_qualified_name"]
if "fully_qualified_name" in fielddef
else None)
m = (re_iliname.match(fully_qualified_name)
if fully_qualified_name else None)
alias = None
if "column_alias" in fielddef:
alias = fielddef["column_alias"]
if m and not alias:
alias = m.group(1)
field = Field(column_name)
field.alias = alias
# Should we hide the field?
hide_attribute = False
if "fully_qualified_name" in fielddef:
fully_qualified_name = fielddef["fully_qualified_name"]
if fully_qualified_name:
meta_attrs_column = self.get_meta_attrs(
fully_qualified_name)
for attr_record in meta_attrs_column:
if attr_record["attr_name"] == "hidden":
if attr_record["attr_value"] == "True":
hide_attribute = True
break
if column_name in IGNORED_FIELDNAMES:
hide_attribute = True
if not basket_handling and column_name in BASKET_FIELDNAMES:
hide_attribute = True
field.hidden = hide_attribute
if column_name in READONLY_FIELDNAMES:
field.read_only = True
if column_name in min_max_info:
field.widget = "Range"
field.widget_config["Min"] = min_max_info[column_name][0]
field.widget_config["Max"] = min_max_info[column_name][1]
if "numeric_scale" in fielddef:
field.widget_config["Step"] = pow(
10, -1 * fielddef["numeric_scale"])
# field.widget_config['Suffix'] = fielddef['unit'] if 'unit' in fielddef else ''
if "unit" in fielddef and fielddef["unit"] is not None:
field.alias = "{alias} [{unit}]".format(
alias=alias or column_name, unit=fielddef["unit"])
if column_name in value_map_info:
field.widget = "ValueMap"
field.widget_config["map"] = [{
val: val
} for val in value_map_info[column_name]]
if "attr_mapping" in fielddef and fielddef[
"attr_mapping"] == "ARRAY":
field.widget = "List"
if "texttype" in fielddef and fielddef["texttype"] == "MTEXT":
field.widget = "TextEdit"
field.widget_config["IsMultiline"] = True
data_type = self._db_connector.map_data_types(
fielddef["data_type"])
if "time" in data_type or "date" in data_type:
field.widget = "DateTime"
field.widget_config["calendar_popup"] = True
dateFormat = QLocale(
QgsApplication.instance().locale()).dateFormat(
QLocale.ShortFormat)
timeFormat = QLocale(
QgsApplication.instance().locale()).timeFormat(
QLocale.ShortFormat)
dateTimeFormat = QLocale(
QgsApplication.instance().locale()).dateTimeFormat(
QLocale.ShortFormat)
if data_type == self._db_connector.QGIS_TIME_TYPE:
field.widget_config["display_format"] = timeFormat
elif data_type == self._db_connector.QGIS_DATE_TIME_TYPE:
field.widget_config["display_format"] = dateTimeFormat
elif data_type == self._db_connector.QGIS_DATE_TYPE:
field.widget_config["display_format"] = dateFormat
db_factory.customize_widget_editor(field, data_type)
if "default_value_expression" in fielddef:
field.default_value_expression = fielddef[
"default_value_expression"]
if basket_handling and column_name in BASKET_FIELDNAMES:
if self.tool in [
DbIliMode.pg,
DbIliMode.ili2pg,
DbIliMode.mssql,
DbIliMode.ili2mssql,
]:
schema_topic_identificator = slugify(
f"{layer.source().host()}_{layer.source().database()}_{layer.source().schema()}_{model_topic_name}"
)
field.default_value_expression = (
f"@{schema_topic_identificator}")
elif self.tool in [DbIliMode.ili2gpkg, DbIliMode.gpkg]:
schema_topic_identificator = slugify(
f"@{layer.source().uri().split('|')[0].strip()}_{model_topic_name}"
)
field.default_value_expression = (
f"@{schema_topic_identificator}")
if "enum_domain" in fielddef and fielddef["enum_domain"]:
field.enum_domain = fielddef["enum_domain"]
layer.fields.append(field)
layers.append(layer)
self.print_messages()
return layers
def __init__(self):
if hasattr(self, 'gh'): # Se inicializa una vez
return
self.gh = None
self.ruta, self.rutaBase = self.calcRuta() # Path de la aplicación
self.cfg = self.readCfg() # Config de instalación
val = self.paramCfg("Debug", "False") # Errores no controlados
if val != "True":
sys.excepthook = _fatalError
self.entorn = self.calcEntorn() # 'DSV' o 'PRO'
self.usuari = getpass.getuser().upper() # Id de usuario
self.sessio = str(uuid.uuid1()) # Id único de sesión
self.intranet = self.calcIntranet() # True si en la intranet
self.dbQvista = _DB_QVISTA[self.entorn] # Conexión Oracle entorno
self.dbGeo = QvSqlite().dbGeoConnexio() # Conexión Geocod SQlite
self.proxy = self.setProxy() # Establecer proxy
val = self.paramCfg('Log', 'False') # Activación log
if val == 'True':
self.log = True
else:
self.log = False
val = self.paramCfg('Github', 'False') # Establecer rama Github
if val == 'False':
self.github = None
elif val == 'True':
self.github = 'master'
else:
self.github = val
if self.github is None:
self.gh = None
else:
val = self.paramCfg('Id', '')
self.gh = QvGithub(self.data(), self.github, val)
val = self.paramCfg('Stdout', 'False') # Activación fichero salida
if val == 'True':
try:
# print(os.getcwd())
sys.stdout = open('../Salida.txt', 'w')
except Exception:
print('Error al redirigir stdout')
self.dbLog = None
self.queryLog = None
self.familyLog = None
self.nameLog = None
self.queryGeo = None
self.appQgis = None
self.idioma = None
self.qtTranslator = None
self.qgisTranslator = None
self.locale = QLocale("ca-ES")
QgsPythonRunner.setInstance(QvPythonRunner()) # Ejecuciones Python
def layers(self, filter_layer_list=[]):
tables_info = self.get_tables_info()
layers = list()
for record in tables_info:
# When in PostGIS mode, leaving schema blank should load tables from
# all schemas, except the ignored ones
if self.schema:
if record['schemaname'] != self.schema:
continue
elif record['schemaname'] in IGNORED_SCHEMAS:
continue
if record['tablename'] in IGNORED_TABLES:
continue
if filter_layer_list and record[
'tablename'] not in filter_layer_list:
continue
if self.tool_name == 'ili2pg':
provider = 'postgres'
if record['geometry_column']:
data_source_uri = '{uri} key={primary_key} estimatedmetadata=true srid={srid} type={type} table="{schema}"."{table}" ({geometry_column})'.format(
uri=self.uri,
primary_key=record['primary_key'],
srid=record['srid'],
type=record['type'],
schema=record['schemaname'],
table=record['tablename'],
geometry_column=record['geometry_column'])
else:
data_source_uri = '{uri} key={primary_key} table="{schema}"."{table}"'.format(
uri=self.uri,
primary_key=record['primary_key'],
schema=record['schemaname'],
table=record['tablename'])
elif self.tool_name == 'ili2gpkg':
provider = 'ogr'
data_source_uri = '{uri}|layername={table}'.format(
uri=self.uri, table=record['tablename'])
alias = record['table_alias'] if 'table_alias' in record else ''
is_domain = record['kind_settings'] == 'ENUM' or record[
'kind_settings'] == 'CATALOGUE' if 'kind_settings' in record else False
is_nmrel = record[
'kind_settings'] == 'ASSOCIATION' if 'kind_settings' in record else False
layer = Layer(
provider, data_source_uri, record['tablename'],
record['geometry_column'],
QgsWkbTypes.parseType(record['type']) or QgsWkbTypes.Unknown,
alias, is_domain, is_nmrel)
# Configure fields for current table
fields_info = self.get_fields_info(record['tablename'])
constraints_info = self.get_constraints_info(record['tablename'])
re_iliname = re.compile(r'^@iliname (.*)$')
for fielddef in fields_info:
column_name = fielddef['column_name']
comment = fielddef['comment']
m = re_iliname.match(comment) if comment else None
alias = None
if 'column_alias' in fielddef:
alias = fielddef['column_alias']
if m and not alias:
alias = m.group(1)
field = Field(column_name)
field.alias = alias
if column_name in IGNORED_FIELDNAMES:
field.widget = 'Hidden'
if column_name in READONLY_FIELDNAMES:
field.read_only = True
if column_name in constraints_info:
field.widget = 'Range'
field.widget_config['Min'] = constraints_info[column_name][
0]
field.widget_config['Max'] = constraints_info[column_name][
1]
# field.widget_config['Suffix'] = fielddef['unit'] if 'unit' in fielddef else ''
if 'unit' in fielddef:
field.alias = '{alias} [{unit}]'.format(
alias=alias or column_name, unit=fielddef['unit'])
if 'texttype' in fielddef and fielddef['texttype'] == 'MTEXT':
field.widget = 'TextEdit'
field.widget_config['IsMultiline'] = True
data_type = self._db_connector.map_data_types(
fielddef['data_type'])
if 'time' in data_type or 'date' in data_type:
field.widget = 'DateTime'
field.widget_config['calendar_popup'] = True
dateFormat = QLocale(
QgsApplication.instance().locale()).dateFormat(
QLocale.ShortFormat)
timeFormat = QLocale(
QgsApplication.instance().locale()).timeFormat(
QLocale.ShortFormat)
dateTimeFormat = QLocale(
QgsApplication.instance().locale()).dateTimeFormat(
QLocale.ShortFormat)
if data_type == self._db_connector.QGIS_TIME_TYPE:
field.widget_config['display_format'] = timeFormat
elif data_type == self._db_connector.QGIS_DATE_TIME_TYPE:
field.widget_config['display_format'] = dateTimeFormat
elif data_type == self._db_connector.QGIS_DATE_TYPE:
field.widget_config['display_format'] = dateFormat
layer.fields.append(field)
layers.append(layer)
return layers
