def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
locale = QSettings().value('locale/userLocale')[0:2]
if not project_id:
self.message_bar.pushCritical(
"Error",
_translate("VeriSO_EE_Geb_Basis", "project_id not set", None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("VeriSO_EE_Geb_Basis",
"Gebaeudeadressen - Basislayer", None)
group += " (" + str(project_id) + ")"
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "Bodenbedeckung", None),
"featuretype":
"bodenbedeckung_boflaeche",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"art_txt LIKE 'Gebaeude%' OR art_txt LIKE "
"'befestigt.Strasse_Weg%' OR art_txt LIKE "
"'befestigt.Trottoir%' OR art_txt LIKE "
"'befestigt.uebrige_befestigte%'",
"readonly":
True,
"group":
group,
"style":
"bodenbedeckung/gebaeude_strassen_trottoir_erschliessung"
".qml"
}
# Use 'LIKE' instead of 'IN' or '='. Now you can model extensions
# like different kinds of 'uebrige_befestigte'.
# Visibility and if legend and/or groupd should be collapsed can
# be set with parameters in the self.layer_loader.load()
# method:
# load(layer, visibility=True, collapsed_legend=False,
# collapsed_group=False)
vlayer = self.layer_loader.load(layer)
# noinspection PyPep8
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "EO.Flaechenelemente", None),
"featuretype":
"v_einzelobjekte_flaechenelement",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"art_txt LIKE 'unterirdisches_Gebaeude%' OR "
"art_txt LIKE 'uebriger_Gebaeudeteil%' OR art_txt "
"LIKE 'Reservoir%' OR art_txt LIKE 'Unterstand%'",
"readonly":
True,
"group":
group,
"style":
"einzelobjekte/eo_flaeche_gebdetail_unterstand_reservoir_unterirdisch.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "EO.Linienelemente", None),
"featuretype":
"v_einzelobjekte_linienelement",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"art_txt LIKE 'uebriger_Gebaeudeteil%'",
"readonly":
True,
"group":
group,
"style":
"einzelobjekte/eo_linie_gebdetail.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_Geb_Basis", "GEB.Nachführung",
None),
"featuretype": "gebaeudeadressen_gebnachfuehrung",
"key": "ogc_fid",
"sql": "",
"readonly": True,
"group": group
}
# layer["geom"] = "perimeter" # Will be loaded as geometryless
# layer.
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "Benanntes Gebiet", None),
"featuretype":
"gebaeudeadressen_benanntesgebiet",
"geom":
"flaeche",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"global_qml/gebaeudeadressen/benanntesgebiet_gruen.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "Strassenstueck (geometrie)",
None),
"featuretype":
"gebaeudeadressen_strassenstueck",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"",
"group":
group,
"style":
"global_qml/gebaeudeadressen/strassenachsen_gruen.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis",
"Strassenstueck (anfangspunkt)", None),
"featuretype":
"gebaeudeadressen_strassenstueck",
"geom":
"anfangspunkt",
"key":
"ogc_fid",
"sql":
"",
"group":
group,
"style":
"global_qml/gebaeudeadressen/anfangspunkt_gruen.qml"
}
vlayer = self.layer_loader.load(layer)
# noinspection PyPep8
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "Gebaeudeeingang", None),
"featuretype":
"gebaeudeadressen_gebaeudeeingang",
"geom":
"lage",
"key":
"ogc_fid",
"sql":
"",
"group":
group,
"style":
"global_qml/gebaeudeadressen/gebaeudeeingang_blaues_viereck_mit_label.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_Geb_Basis", "HausnummerPos",
None),
"featuretype": "v_gebaeudeadressen_hausnummerpos",
"geom": "pos",
"key": "ogc_fid",
"sql": "",
"group": group,
"style": "global_qml/gebaeudeadressen/hausnummerpos.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "LokalisationsName", None),
"featuretype":
"gebaeudeadressen_lokalisationsname",
"key":
"ogc_fid",
"sql":
"",
"group":
group
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "LokalisationsNamePos",
None),
"featuretype":
"t_gebaeudeadressen_lokalisationsnamepos",
"geom":
"pos",
"key":
"ogc_fid",
"sql":
"",
"group":
group,
"style":
"global_qml/gebaeudeadressen/lokalisationsnamepos.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_Geb_Basis", "Gemeindegrenze",
None),
"featuretype": "gemeindegrenzen_gemeindegrenze",
"geom": "geometrie",
"key": "ogc_fid",
"sql": "",
"readonly": True,
"group": group,
"style": "global_qml/gemeindegrenze/gemgre_strichliert.qml"
}
gemgrelayer = self.layer_loader.load(layer)
if gemgrelayer:
rect = gemgrelayer.extent()
rect.scale(5)
self.iface.mapCanvas().setExtent(rect)
self.iface.mapCanvas().refresh()
except Exception as e:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage(
"Error",
str(traceback.format_exc(exc_traceback)),
level=Qgis.Critical,
duration=0)
QApplication.restoreOverrideCursor()
def __init__(self, parent=None):
super(ShellOutputScintilla, self).__init__(parent)
self.parent = parent
self.shell = self.parent.shell
self.settings = QSettings()
# Creates layout for message bar
self.layout = QGridLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.layout.addItem(spacerItem, 1, 0, 1, 1)
# messageBar instance
self.infoBar = QgsMessageBar()
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.infoBar.setSizePolicy(sizePolicy)
self.layout.addWidget(self.infoBar, 0, 0, 1, 1)
# Enable non-ascii chars for editor
self.setUtf8(True)
sys.stdout = writeOut(self, sys.stdout)
sys.stderr = writeOut(self, sys.stderr, "_traceback")
self.insertInitText()
self.refreshSettingsOutput()
self.setReadOnly(True)
# Set the default font
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
# Margin 0 is used for line numbers
self.setMarginWidth(0, 0)
self.setMarginWidth(1, 0)
self.setMarginWidth(2, 0)
#fm = QFontMetrics(font)
self.setMarginsFont(font)
self.setMarginWidth(1, "00000")
self.setMarginLineNumbers(1, True)
self.setMarginsForegroundColor(QColor("#3E3EE3"))
self.setMarginsBackgroundColor(QColor("#f9f9f9"))
self.setCaretLineVisible(True)
self.setCaretWidth(0)
self.setMinimumHeight(120)
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
self.runScut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_E), self)
self.runScut.setContext(Qt.WidgetShortcut)
self.runScut.activated.connect(self.enteredSelected)
# Reimplemeted copy action to prevent paste prompt (>>>,...) in command view
self.copyShortcut = QShortcut(QKeySequence.Copy, self)
self.copyShortcut.activated.connect(self.copy)
self.selectAllShortcut = QShortcut(QKeySequence.SelectAll, self)
self.selectAllShortcut.activated.connect(self.selectAll)
# -*- coding: utf-8 -*-
""" A script to remove Isogeo's settings from QGIS' settings.
Usefull to test first authentication to Isogeo plugin.
"""
from qgis.PyQt.QtCore import QSettings
qsettings = QSettings()
if "isogeo" in qsettings.childGroups():
print("'isogeo' child group detected in QSettings --> removing it")
qsettings.remove("isogeo")
else:
print("QSettings already cleared")
def dbConnectionNames():
settings = QSettings()
settings.beginGroup('/PostgreSQL/connections/')
return settings.childGroups()
def setUp(self):
"""Fixture run before all tests."""
self.qsetting = QSettings(INASAFE_TEST)
self.qsetting.clear()
from QGIS_FMV.manager.QgsFmvOpenStream import OpenStream
from QGIS_FMV.player.QgsFmvPlayer import QgsFmvPlayer
from QGIS_FMV.utils.QgsFmvUtils import (askForFiles, BufferedMetaReader,
initElevationModel, AddVideoToSettings,
RemoveVideoToSettings,
RemoveVideoFolder, getVideoFolder,
getVideoManagerList, getNameSpace,
getVideoLocationInfo)
from QGIS_FMV.utils.QgsUtils import QgsUtils as qgsu
try:
from pydevd import *
except ImportError:
None
s = QSettings()
parser = ConfigParser()
parser.read(os.path.join(dirname(dirname(abspath(__file__))), 'settings.ini'))
class FmvManager(QDockWidget, Ui_ManagerWindow):
''' Video Manager '''
def __init__(self, iface, parent=None):
super().__init__(parent)
self.setupUi(self)
self.parent = parent
self.iface = iface
self._PlayerDlg = None
self.isStreaming = False
self.meta_reader = {}
self.initialPt = {}
def enableCompiler(self):
QSettings().setValue('/qgis/compileExpressions', True)
def getLastUsedEncoding():
settings = QSettings()
return settings.value("/UI/encoding", u"System", type=str)
def setLastUsedEncoding(encoding):
settings = QSettings()
settings.setValue("/UI/encoding", encoding)
def getHelpPath():
settings = QSettings()
return settings.value("/GdalTools/helpPath", u"", type=str)
def setHelpPath(path):
settings = QSettings()
settings.setValue("/GdalTools/helpPath", path)
def __init__(self, iface, parent=None):
QMainWindow.__init__(self, parent)
if QApplication.overrideCursor():
QApplication.restoreOverrideCursor()
self.setAttribute(Qt.WA_DeleteOnClose)
tdir = os.path.dirname(os.path.realpath(__file__))
uif = os.path.join(tdir, "ui", "ui_rivergis.ui")
self.ui = uic.loadUi(uif, self)
self.conn = None
self.curConnName = None
self.schema = None
self.passwd = None
self.rdb = None
self.iface = iface
# self.mapRegistry = QgsMapLayerRegistry.instance()
self.rivergisPath = os.path.dirname(__file__)
self.dtms = []
# restore settings
self.readSettings()
self.menus = self.ui.menubar.findChildren(QMenu)
self.toolbars = self.findChildren(QToolBar)
# MENU Actions
# DB
self.ui.actionRefreshConnections.triggered.connect(self.connChanged)
self.ui.actionCreateNewSchema.triggered.connect(self.dbCreateSchema)
self.ui.actionDeleteSchema.triggered.connect(self.dbDeleteSchema)
self.ui.actionRASCreateRdbTables.triggered.connect(
self.rasCreateRdbTables)
self.ui.actionRASLoadRdbTablesIntoQGIS.triggered.connect(
self.rasLoadRdbTablesIntoQGIS)
self.ui.actionRASImportLayersIntoRdbTables.triggered.connect(
self.rasImportLayersIntoRdbTables)
# Settings
self.ui.actionOptions.triggered.connect(self.options)
self.ui.actionRestoreDefaultOptions.triggered.connect(
lambda: self.readSettings(defaults=True))
# RAS Geometry
# 1D
self.ui.actionRASTopology1D.triggered.connect(
lambda: r1d.ras1dStreamCenterlineTopology(self))
self.ui.actionRASLengthsStations.triggered.connect(
lambda: r1d.ras1dStreamCenterlineLengthsStations(self))
self.ui.actionCopyStreamCenterlines2Flowpaths.triggered.connect(
lambda: r1d.ras1dStreamCenterlines2Flowpaths(self))
self.ui.actionRASStreamCenterlineAll.triggered.connect(
lambda: r1d.ras1dStreamCenterlineAll(self))
self.ui.actionRASXSRiverReachNames.triggered.connect(
lambda: r1d.ras1dXSRiverReachNames(self))
self.ui.actionRASXSStationing.triggered.connect(
lambda: r1d.ras1dXSStationing(self))
self.ui.actionRASXSBankStations.triggered.connect(
lambda: r1d.ras1dXSBankStations(self))
self.ui.actionRASXSDownstreamReachLengths.triggered.connect(
lambda: r1d.ras1dXSDownstreamLengths(self))
self.ui.actionRASXSElevations.triggered.connect(
lambda: r1d.ras1dXSElevations(self))
self.ui.actionRASXSAll.triggered.connect(lambda: r1d.ras1dXSAll(self))
self.ui.actionRASHealLanduseGeometries.triggered.connect(
lambda: r1d.ras1dHealLanduseGeoms(self))
self.ui.actionRASManningsNValues.triggered.connect(
lambda: r1d.ras1dXSExtractMannings(self))
self.ui.actionRASLevees.triggered.connect(
lambda: r1d.ras1dLevees(self))
self.ui.actionRASIneffectiveFlowAreas.triggered.connect(
lambda: r1d.ras1dIneffective(self))
self.ui.actionRASBlockedObstructions.triggered.connect(
lambda: r1d.ras1dObstructions(self))
self.ui.actionRASXSUpdateInsertMeasuredPoints.triggered.connect(
lambda: r1d.ras1dXSUpdateInsertMeasuredPts(self))
self.ui.actionRASBRRiverReachNames.triggered.connect(
lambda: r1d.ras1dBRRiverReachNames(self))
self.ui.actionRASBRStationing.triggered.connect(
lambda: r1d.ras1dBRStationing(self))
self.ui.actionRASBRElevations.triggered.connect(
lambda: r1d.ras1dBRElevations(self))
self.ui.actionRASBRAll.triggered.connect(
lambda: r1d.ras1dRASBRAll(self))
self.ui.actionRASInlRiverReachNames.triggered.connect(
lambda: r1d.ras1dISRiverReachNames(self))
self.ui.actionRASInlStationing.triggered.connect(
lambda: r1d.ras1dISStationing(self))
self.ui.actionRASInlElevations.triggered.connect(
lambda: r1d.ras1dISElevations(self))
self.ui.actionRASInlAll.triggered.connect(lambda: r1d.ras1dISAll(self))
self.ui.actionRASLatRiverReachNames.triggered.connect(
lambda: r1d.ras1dLatRiverReachNames(self))
self.ui.actionRASLatStationing.triggered.connect(
lambda: r1d.ras1dLatStationing(self))
self.ui.actionRASLatElevations.triggered.connect(
lambda: r1d.ras1dLatElevations(self))
self.ui.actionRASLatAll.triggered.connect(
lambda: r1d.ras1dLatAll(self))
self.ui.actionRASSAElevationVolumeData.triggered.connect(
lambda: r1d.ras1dSAVolumeData(self))
self.ui.actionRASSATerrainPointExtraction.triggered.connect(
lambda: r1d.ras1dSAElevations(self))
self.ui.actionRASSAAll.triggered.connect(lambda: r1d.ras1dSAAll(self))
self.ui.actionRASSacAssignNearestSA.triggered.connect(
lambda: r1d.ras1dSACAssignNearestSA(self))
self.ui.actionRASSacElevations.triggered.connect(
lambda: r1d.ras1dSACElevations(self))
self.ui.actionRASSacAll.triggered.connect(
lambda: r1d.ras1dSACAll(self))
self.ui.actionRASCreateRASGISImport.triggered.connect(
lambda: r1d.ras1dCreateRasGisImportFile(self))
# 2D
self.ui.actionRASCreate2dAreaPoints.triggered.connect(
lambda: r2d.ras2dCreate2dPoints(self))
self.ui.actionRASPreview2DMesh.triggered.connect(
lambda: r2d.ras2dPreviewMesh(self))
self.ui.actionRASSave2DPointsToHECRASGeometry.triggered.connect(
lambda: r2d.ras2dSaveMeshPtsToGeometry(self))
# HELP
self.ui.actionHelpContents.triggered.connect(self.showRGisHelp)
self.ui.actionWebsite.triggered.connect(self.showWebsite)
self.ui.actionAbout.triggered.connect(self.about)
# combos
self.ui.crsWidget.crsChanged.connect(self.updateDefaultCrs)
self.ui.connsCbo.activated.connect(self.connChanged)
self.ui.schemasCbo.activated.connect(self.schemaChanged)
# Welcome message
self.ui.textEdit.append(
'<b>Welcome to RiverGIS!</b><br><br>Start building your model with 3 simple steps:<br>1. <b>Choose a connection</b> to PostGIS database<br>2. choose or create database <b>schema</b> (schema = model container or folder)<br>3. select a <b>projection</b> for the river database objects (projection = Coordinate Reference System, CRS).'
)
self.ui.textEdit.append(
'<br>If you can\'t see any connection, please, create a new one from menu Layer > Add layer > Add PostGIS layers... <br>'
)
self.ui.textEdit.append(
'----------------------------------------------------------------------------'
)
# restore the window state
s = QSettings()
self.restoreGeometry(
s.value("/rivergis/mainWindow/geometry",
QByteArray(),
type=QByteArray))
self.restoreState(
s.value("/rivergis/mainWindow/windowState",
QByteArray(),
type=QByteArray))
# get PostGIS connections details and populate connections' combo
self.connChanged()
# restore settings
self.readSettings()
# set QGIS projection CRS as a default for RiverGIS
self.ui.crsWidget.setCrs(
self.iface.mapCanvas().mapSettings().destinationCrs())
self.updateDefaultCrs()
# check if we should connect to previously used RDB
if self.open_last_conn:
try:
self.connChanged(conn_name=self.opts['rdb']['last_conn'],
schema_name=self.opts['rdb']['last_schema'])
except:
pass
# disable some actions until a connection to river database is established
if not self.rdb:
self.disableActions()
def connChanged(self, conn_name='', schema_name=''):
# close any existing connection to a river database
if self.rdb:
self.addInfo(
"Closing existing connection to {0}@{1} river database".format(
self.rdb.dbname, self.rdb.host))
self.rdb.disconnect_pg()
self.rdb = None
else:
pass
s = QSettings()
s.beginGroup('/PostgreSQL/connections')
connsNames = s.childGroups()
if conn_name in connsNames:
self.curConnName = conn_name
else:
self.curConnName = self.ui.connsCbo.currentText()
self.ui.connsCbo.clear()
self.ui.connsCbo.addItem('')
for conn in connsNames:
self.ui.connsCbo.addItem(conn)
try:
i = connsNames.index(self.curConnName) + 1
except ValueError:
i = 0
self.ui.connsCbo.setCurrentIndex(i)
if self.ui.connsCbo.currentIndex() == 0:
self.ui.schemasCbo.clear()
self.ui.schemasCbo.addItem('')
self.disableActions()
return
connName = self.ui.connsCbo.currentText()
s.endGroup()
s.beginGroup('/PostgreSQL/connections/{0}'.format(connName))
# first try to get the credentials from AuthManager, then from the basic settings
authconf = s.value('authcfg', None)
if authconf:
auth_manager = QgsApplication.authManager()
conf = QgsAuthMethodConfig()
auth_manager.loadAuthenticationConfig(authconf, conf, True)
if conf.id():
self.user = conf.config('username', '')
self.passwd = conf.config('password', '')
else:
self.user = s.value('username')
self.passwd = s.value('password')
self.host = s.value('host')
self.port = s.value('port')
self.database = s.value('database')
s.endGroup()
# create a new connection to river database
self.rdb = rivdb.RiverDatabase(self, self.database, self.host,
self.port, self.user, self.passwd)
self.rdb.SRID = int(self.crs.postgisSrid())
if self.rdb.connect_pg():
self.addInfo(
'Created connection to river database: {0}@{1}'.format(
self.rdb.dbname, self.rdb.host))
self.rdb.last_conn = connName
else:
info = 'Couldn\'t connect to river database: {0}@{1}'.format(
self.rdb.dbname, self.rdb.host)
info += '\nPlease, check you database connection settings!'
self.addInfo(info)
self.ui.schemasCbo.clear()
return
# refresh schemas combo
schemaName = self.ui.schemasCbo.currentText()
qry = "SELECT nspname FROM pg_namespace WHERE nspname !~ '^pg_' AND nspname != 'information_schema' ORDER BY nspname"
schemas = self.rdb.run_query(qry, fetch=True)
self.ui.schemasCbo.clear()
self.ui.schemasCbo.addItem('')
if not schemas:
schemas = []
for schema in schemas:
self.ui.schemasCbo.addItem(schema[0])
if schema_name:
schemaExists = self.ui.schemasCbo.findText(schema_name)
else:
schemaExists = self.ui.schemasCbo.findText(schemaName)
if schemaExists:
self.ui.schemasCbo.setCurrentIndex(schemaExists)
self.enableDBActions()
self.schemaChanged()
def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
self.project_dir = self.settings.value("project/projectdir")
self.project_id = self.settings.value("project/id")
locale = QSettings().value('locale/userLocale')[
0:2] # this is for multilingual legends
if locale == "fr":
pass
elif locale == "it":
pass
else:
locale = "de"
if not project_id:
self.message_bar.pushCritical(
"Error",
_translate("VeriSO_PNF_Baugebiet", "project_id not "
"set", None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("VeriSO_PNF_Baugebiet",
"Checklayer - Bebautes Gebiet", None)
group += " (" + str(project_id) + ")"
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "BB.Objektname 'u.'", None),
"featuretype":
"t_bbobj_u",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Objektname 'u.'", None),
"featuretype":
"t_eoobj_u",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"EO.Treppe nicht ein Objekt", None),
"featuretype":
"t_treppe_modellbildung",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"EO.Flächenelement 'übrig. Geb.teil' freistehend",
None),
"featuretype":
"t_gebteil_frei",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate(
"VeriSO_PNF_Baugebiet",
"EO.Linienelement 'übrig. Geb.teil' ausserhalb Gebäude",
None),
"featuretype":
"t_gebteil_ausserhalb",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate(
"VeriSO_PNF_Baugebiet",
"EO.Flächenelement 'übrig. Geb.teil' innerhalb Gebäude",
None),
"featuretype":
"t_gebteil_geb",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Pfeiler im Gebäude",
None),
"featuretype":
"t_pfeiler_gebaeude",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"EO.uebriger_Gebaeudeteil < 1.5 m2", None),
"featuretype":
"t_gebteil_15",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "Ein EO.Objekt pro Element",
None),
"featuretype":
"t_eo_modellbildung",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"BB. Wasserbecken mit EO.Mauer", None),
"featuretype":
"t_mauer_wasserbecken",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Linienelement Mauer",
None),
"featuretype":
"t_mauer_linien",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate(
"VeriSO_PNF_Baugebiet",
"EO Linienelement Mauer ausserhalb EO.Flächenelement Mauer",
None),
"featuretype":
"t_mauer_ausserhalb",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Mauer freistehend",
None),
"featuretype":
"t_mauer_freistehend",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Mauer nicht ein Objekt",
None),
"featuretype":
"t_mauer_modellbildung",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"BB.Gebaeude ohne Gartenanlage", None),
"featuretype":
"t_abgrenzung_gartenanlage",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"BB.Gebaeude ohne Erschliessung", None),
"featuretype":
"t_geb_ohne_ersch",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "BB.Parkplatz < 100 m2",
None),
"featuretype":
"t_pp_kleiner_100",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"BB.Gebaeude mit mehreren Adressen", None),
"featuretype":
"t_2_gebein",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "BB.Gebaeude < 6 m2", None),
"featuretype":
"t_gebaeude_kleiner_6",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"EO.Linienelement unterird. Gebaeude", None),
"featuretype":
"t_u_geb_linien",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Unterstand auf Gebäude",
None),
"featuretype":
"t_unterstand_auf_geb",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
except Exception:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage(
"Error",
str(traceback.format_exc(exc_traceback)),
level=QgsMessageBar.CRITICAL,
duration=0)
QApplication.restoreOverrideCursor()
def setUp(self):
self.cnt += 1
h, path = tempfile.mkstemp('.ini')
assert QgsSettings.setGlobalSettingsPath(path)
self.settings = QgsSettings('testqgissettings', 'testqgissettings%s' % self.cnt)
self.globalsettings = QSettings(self.settings.globalSettingsPath(), QSettings.IniFormat)
def getFilter(self, typeName):
settings = QSettings()
return settings.value("/GdalTools/" + typeName + "FileFilter",
u"",
type=str)
def __init__(self, alg=None):
super(ModelerDialog, self).__init__(None)
self.setupUi(self)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().insertWidget(1, self.bar)
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowCloseButtonHint)
settings = QSettings()
self.splitter.restoreState(
settings.value("/Processing/splitterModeler", QByteArray()))
self.restoreGeometry(
settings.value("/Processing/geometryModeler", QByteArray()))
self.tabWidget.setCurrentIndex(0)
self.scene = ModelerScene(self)
self.scene.setSceneRect(
QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText():
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasText():
text = event.mimeData().text()
if text in ModelerParameterDefinitionDialog.paramTypes:
self.addInputOfType(text, event.pos())
else:
alg = algList.getAlgorithm(text)
if alg is not None:
self._addAlgorithm(alg.getCopy(), event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText():
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
self.repaintModel()
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
QGraphicsView.mousePressEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(
self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(
self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].text(0)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
def _mimeDataAlgorithm(items):
item = items[0]
if isinstance(item, TreeAlgorithmItem):
mimeData = QMimeData()
mimeData.setText(item.alg.commandLineName())
return mimeData
self.algorithmTree.mimeData = _mimeDataAlgorithm
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
# Set icons
self.btnOpen.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.btnSave.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.btnSaveAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.btnExportImage.setIcon(
QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg'))
self.btnExportPython.setIcon(
QgsApplication.getThemeIcon('/console/iconSaveAsConsole.png'))
self.btnEditHelp.setIcon(
QIcon(os.path.join(pluginPath, 'images', 'edithelp.png')))
self.btnRun.setIcon(
QIcon(os.path.join(pluginPath, 'images', 'runalgorithm.png')))
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(self.tr('Search...'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(
self.tr('[Enter model name here]'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(
self.tr('[Enter group name here]'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.fillAlgorithmTree)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
self.btnOpen.clicked.connect(self.openModel)
self.btnSave.clicked.connect(self.save)
self.btnSaveAs.clicked.connect(self.saveAs)
self.btnExportImage.clicked.connect(self.exportAsImage)
self.btnExportPython.clicked.connect(self.exportAsPython)
self.btnEditHelp.clicked.connect(self.editHelp)
self.btnRun.clicked.connect(self.runModel)
if alg is not None:
self.alg = alg
self.textGroup.setText(alg.group)
self.textName.setText(alg.name)
self.repaintModel()
else:
self.alg = ModelerAlgorithm()
self.alg.modelerdialog = self
self.fillInputsTree()
self.fillAlgorithmTree()
self.view.centerOn(0, 0)
self.alg.setModelerView(self)
self.help = None
self.hasChanged = False
def setFilter(self, typeName, aFilter):
settings = QSettings()
settings.setValue("/GdalTools/" + typeName + "FileFilter", aFilter)
def addConnection(self, conn_name, uri):
settings = QSettings()
settings.beginGroup(u"/%s/%s" %
(self.connectionSettingsKey(), conn_name))
settings.setValue("sqlitepath", uri.database())
return True
def getLastUsedDir():
settings = QSettings()
lastProjectDir = settings.value("/UI/lastProjectDir", u".", type=str)
return settings.value("/GdalTools/lastUsedDir", lastProjectDir, type=str)
def disableCompiler(self):
QSettings().setValue('/qgis/compileExpressions', False)
def getGdalBinPath():
settings = QSettings()
return settings.value("/GdalTools/gdalPath", u"", type=str)
def remove_connection(conn_name):
settings = QSettings()
settings.remove(DbConnectionCfg.connection_key(conn_name))
def setGdalBinPath(path):
settings = QSettings()
settings.setValue("/GdalTools/gdalPath", path)
def __init__(self):
"""Constructor. Create the settings objects"""
self.s = QSettings()
self.p = QgsProject.instance()
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 = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'NextcloudPhonetrack_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&Nextcloud Phonetrack Link')
# Check if plugin was started the first time in current QGIS session
# Must be set in initGui() to survive plugin reloads
self.first_start = None
# Variables which are used for lines with no color set. nextautoclor is the index of the next color.
self.colorlist = [
"blue", "red", "green", "yellow", "cyan", "magenta", "gray",
"white", "black", "darkblue", "darkred", "darkgreen", "darkyellow",
"darkmagenta", "darkmagenta"
]
self.nextautocolor = 0
# The following variables are first declared here (mostly for clarity), they will be reset when sync is started
# This variables are used to store the three layer objects and the corresponding data provider for them
# Layer for all Positions with symbols
self.layerall = None
self.providerall = None
# Layer for all Positions with lines
self.layerallline = None
self.provideralllineprovider = None
# Layer for the last Positions wit symbols
self.layerlast = None
self.providerlast = None
# Timer object used for regular updates
self.timer = None
# Categorical renderer for the Positions layer (with points and lines)
self.catrenderer = None
self.catrendererline = None
# Dictionaries to store the timestamp of the last received point for each line
self.linenamesall = {}
# Dictionaries to store the last point for each line. This is needed to append the line.
self.lastpointsall = {}
# The URL for syncing all points
self.urlall = ""
# The URL for syncing the last position
self.urllast = ""
# The min value for all timestamps, points with lower timestamps are not shown.
# Originally this was intended for all lines, but as the timestamps might be set by the client it is possible,
# that one device is running more than the sync intervall before all other devices. Therefore it is possible to
# store the last timestamp for each device seperate. This vars only hold the time set in the dialog.
self.lasttimeallrec = 0
self.lasttimelastrec = 0
# Variable to store the sync intervall (0 means only one initial sync)
self.intervall = 0
# Variable to store the number of max points loaded for first sync
self.maxfirstsync = 0
# Variable to store the number of max points loaded for all following syncs
self.maxsync = 0
# This Variable is first set to maxfirstsync and at the end of the first sync set to maxsync.
self.nextmaxsync = 0
def save_settings(self):
settings = QSettings()
settings.setValue(
'Asistente-LADM_COL/wizards/physical_zone_valuation_load_data_type',
'digitizing' if self.rad_digitizing.isChecked() else 'refactor')
def __init__(self, alg):
super(AlgorithmDialogBase, self).__init__(iface.mainWindow())
self.setupUi(self)
self.settings = QSettings()
self.restoreGeometry(
self.settings.value("/Processing/dialogBase", QByteArray()))
self.executed = False
self.mainWidget = None
self.alg = alg
# Rename OK button to Run
self.btnRun = self.buttonBox.button(QDialogButtonBox.Ok)
self.btnRun.setText(self.tr('Run'))
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.setWindowTitle(self.alg.displayName())
#~ desktop = QDesktopWidget()
#~ if desktop.physicalDpiX() > 96:
#~ self.txtHelp.setZoomFactor(desktop.physicalDpiX() / 96)
algHelp = self.alg.shortHelp()
if algHelp is None:
self.textShortHelp.setVisible(False)
else:
self.textShortHelp.document().setDefaultStyleSheet(
'''.summary { margin-left: 10px; margin-right: 10px; }
h2 { color: #555555; padding-bottom: 15px; }
a { text-decoration: none; color: #3498db; font-weight: bold; }
p { color: #666666; }
b { color: #333333; }
dl dd { margin-bottom: 5px; }'''
)
self.textShortHelp.setHtml(algHelp)
self.textShortHelp.setOpenLinks(False)
def linkClicked(url):
webbrowser.open(url.toString())
self.textShortHelp.anchorClicked.connect(linkClicked)
isText, algHelp = self.alg.help()
if algHelp is not None:
algHelp = algHelp if isText else QUrl(algHelp)
try:
if isText:
self.txtHelp.setHtml(algHelp)
else:
html = self.tr(
'<p>Downloading algorithm help... Please wait.</p>')
self.txtHelp.setHtml(html)
rq = QNetworkRequest(algHelp)
self.reply = QgsNetworkAccessManager.instance().get(rq)
self.reply.finished.connect(self.requestFinished)
except Exception as e:
self.tabWidget.removeTab(2)
else:
self.tabWidget.removeTab(2)
self.showDebug = ProcessingConfig.getSetting(
ProcessingConfig.SHOW_DEBUG_IN_DIALOG)
def __init__(self, algType, alg):
super(ScriptEditorDialog, self).__init__(None)
self.setupUi(self)
self.setWindowFlags(Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowCloseButtonHint)
settings = QSettings()
self.restoreState(
settings.value("/Processing/stateScriptEditor", QByteArray()))
self.restoreGeometry(
settings.value("/Processing/geometryScriptEditor", QByteArray()))
iconSize = settings.value("iconsize", 24)
self.toolBar.setIconSize(QSize(iconSize, iconSize))
self.actionOpenScript.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.actionSaveScript.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.actionSaveScriptAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.actionEditScriptHelp.setIcon(
QgsApplication.getThemeIcon('/mActionEditHelpContent.svg'))
self.actionRunScript.setIcon(
QgsApplication.getThemeIcon('/mActionStart.svg'))
self.actionCut.setIcon(
QgsApplication.getThemeIcon('/mActionEditCut.svg'))
self.actionCopy.setIcon(
QgsApplication.getThemeIcon('/mActionEditCopy.svg'))
self.actionPaste.setIcon(
QgsApplication.getThemeIcon('/mActionEditPaste.svg'))
self.actionUndo.setIcon(
QgsApplication.getThemeIcon('/mActionUndo.svg'))
self.actionRedo.setIcon(
QgsApplication.getThemeIcon('/mActionRedo.svg'))
self.actionIncreaseFontSize.setIcon(
QgsApplication.getThemeIcon('/mActionIncreaseFont.svg'))
self.actionDecreaseFontSize.setIcon(
QgsApplication.getThemeIcon('/mActionDecreaseFont.svg'))
# Connect signals and slots
self.actionOpenScript.triggered.connect(self.openScript)
self.actionSaveScript.triggered.connect(self.save)
self.actionSaveScriptAs.triggered.connect(self.saveAs)
self.actionEditScriptHelp.triggered.connect(self.editHelp)
self.actionRunScript.triggered.connect(self.runAlgorithm)
self.actionCut.triggered.connect(self.editor.cut)
self.actionCopy.triggered.connect(self.editor.copy)
self.actionPaste.triggered.connect(self.editor.paste)
self.actionUndo.triggered.connect(self.editor.undo)
self.actionRedo.triggered.connect(self.editor.redo)
self.actionIncreaseFontSize.triggered.connect(self.editor.zoomIn)
self.actionDecreaseFontSize.triggered.connect(self.editor.zoomOut)
self.editor.textChanged.connect(lambda: self.setHasChanged(True))
self.alg = alg
self.algType = algType
self.snippets = {}
if self.algType == self.SCRIPT_PYTHON:
path = os.path.join(os.path.dirname(os.path.dirname(__file__)),
"script", "snippets.py")
with codecs.open(path, 'r', encoding='utf-8') as f:
lines = f.readlines()
snippetlines = []
name = None
for line in lines:
if line.startswith("##"):
if snippetlines:
self.snippets[name] = "".join(snippetlines)
name = line[2:]
snippetlines = []
else:
snippetlines.append(line)
if snippetlines:
self.snippets[name] = "".join(snippetlines)
#if self.snippets:
# self.btnSnippets.setVisible(False)
if self.alg is not None:
self.filename = self.alg.descriptionFile
self.editor.setText(self.alg.script)
else:
self.filename = None
self.update = False
self.help = None
self.setHasChanged(False)
self.editor.setLexerType(self.algType)
def create_project(self, project_name, project_dir, is_public, namespace):
"""
Create new Mergin project.
If project_dir is None, we are creating empty project without upload.
"""
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
self.mc.create_project(project_name, is_public, namespace)
except Exception as e:
QApplication.restoreOverrideCursor()
QMessageBox.critical(None, "Create Project",
"Failed to create Mergin project.\n" + str(e))
return False
QApplication.restoreOverrideCursor()
if not project_dir:
# not going to upload anything so just pop a "success" message and exit
QMessageBox.information(
None, "Create Project",
"An empty project has been created on the server",
QMessageBox.Close)
return True
# let's do initial upload of the project data
mp = MerginProject(project_dir)
full_project_name = "{}/{}".format(namespace, project_name)
mp.metadata = {"name": full_project_name, "version": "v0", "files": []}
if not mp.inspect_files():
QMessageBox.warning(
None, "Create Project",
"The project directory is empty - nothing to upload.")
return True
dlg = SyncDialog()
dlg.push_start(self.mc, project_dir, full_project_name)
dlg.exec_() # blocks until success, failure or cancellation
if dlg.exception:
# push failed for some reason
if isinstance(dlg.exception, LoginError):
login_error_message(dlg.exception)
elif isinstance(dlg.exception, ClientError):
QMessageBox.critical(None, "Project sync",
"Client error: " + str(dlg.exception))
else:
unhandled_exception_message(
dlg.exception_details(),
"Project sync",
f"Failed to sync project {project_name} due to an unhandled exception.",
)
return True
if not dlg.is_complete:
# we were cancelled - but no need to show a message box about that...?
return True
settings = QSettings()
server_url = self.mc.url.rstrip("/")
settings.setValue(f"Mergin/localProjects/{full_project_name}/path",
project_dir)
settings.setValue(f"Mergin/localProjects/{full_project_name}/server",
server_url)
if (project_dir == QgsProject.instance().absolutePath()
or project_dir + "/" in QgsProject.instance().absolutePath()):
write_project_variables(self.mc.username(), project_name,
full_project_name, "v1", server_url)
QMessageBox.information(
None, "Create Project",
"Mergin project created and uploaded successfully",
QMessageBox.Close)
return True
