def lessThan(self, left, right):
c = self.sortColumn()
a = self.model.data(left)
b = self.model.data(right)
if c in (0, 2):
return a < b
if c == 3:
fmtr = "%d %b %Y %H:%M:%S"
fmtw = "%Y-%m-%d %H:%M:%S"
ad = time.strptime(str(a), fmtr)
bd = time.strptime(str(b), fmtr)
af = time.strftime(fmtw, ad)
bf = time.strftime(fmtw, bd)
return af < bf
if c == 1:
wg = {'MB': 1e3, 'GB': 1e6, 'KB': 1}
try:
(av, au) = a.split()
(bv, bu) = b.split()
except ValueError:
return a < b
av = float(str.replace(av, ',', '.')) * wg[au]
bv = float(str.replace(bv, ',', '.')) * wg[bu]
return av < bv
return 1
def xyt_name_factory(filepath, wlen, smr, frac, original):
# Returns the filename that _xyt output should have.
# Will have the general behavior: filename_xyt00.format
# filepath ~ dirname/name.fits
# filename ~ dirname/name
# fnmatch_string ~ name + xyt_suffix + ?? + xyt_format
# Remove RHT-specific endings
filename = filename_from_path(filepath)
dirname = os.path.dirname(os.path.abspath(filepath))
fnmatch_string = filename + xyt_suffix + '?' * DIGITS + xyt_format
xyt_files = fnmatch.filter(os.listdir(dirname), fnmatch_string)
xyt_array = [None] * (10**DIGITS)
# Try to find a parameter match among existing files
left = str.find(fnmatch_string, '?')
for x in xyt_files:
abs_x = os.path.join(dirname, x)
if getXYT(
abs_x,
match_only={
'WLEN': wlen,
'SMR': smr,
'FRAC': frac,
'ORIGINAL': original
}
): #TODO ______________________________________#print 'Found _xyt file matching your input parameters!'
return os.path.normpath(abs_x)
else:
xyt_array[int(x[left:(left + DIGITS)])] = x
# Try to find the lowest-numbered name that is unoccupied
for i, y in enumerate(xyt_array):
if y is None:
# Print 'Found _xyt available for these parameters!'
int_string = str.zfill(str(i), DIGITS)[:DIGITS]
xyt_filename = filename + xyt_suffix + int_string + xyt_format
return os.path.normpath(os.path.join(dirname, xyt_filename))
# Failure: No match and no available output slots
xyt_filename = str.replace(fnmatch_string, '?', '0')
print(
'In xyt_filename(): No existing ouput matches the input parameters and no namespace is available'
)
print('Overwrite ' + xyt_filename + '?..')
choice = input(' [y]/n/' + '0' * (DIGITS - 1) + 'x')
if len(choice) == 0 or choice == 'y':
return os.path.normpath(os.path.join(dirname, xyt_filename))
elif choice != 'n':
int_string = str.zfill(str(int(choice)), DIGITS)[:DIGITS]
xyt_filename = filename + xyt_suffix + int_string + xyt_format
return os.path.normpath(os.path.join(dirname, xyt_filename))
else:
raise RuntimeError(
'In xyt_filename(): No existing ouput matches the input parameters and no namespace is available'
)
def get_vrouter_logs(self):
print('\nTASK : copy vrouter logs')
print("\nDumping the output of commands to files")
commands = [
'nh --list', 'vrouter --info', 'dropstats', 'dropstats -l 0',
'vif --list', 'mpls --dump', 'vxlan --dump', 'vrfstats --dump',
'vrmemstats', 'qosmap --dump-fc', 'qosmap --dump-qos',
'mirror --dump', 'virsh list', 'ip ad', 'ip r', 'flow -s'
]
myCmd = 'mkdir /tmp/vrouter_logs'
cmd_op = self.get_ssh_cmd_output(myCmd)
for i in range(len(commands)):
str = commands[i]
if str == "dropstats" or str == "dropstats -l 0":
self.run_command_interval_times(str, 5,
5) #command,interval,times
elif str == "flow -s":
self.run_command_interval_times(str, 20,
1) #command,interval,times
else:
str_file_name = str.replace(' ', '')
myCmd = 'docker exec vrouter_vrouter-agent_1 /bin/sh -c "%s" \
>> /tmp/vrouter_logs/%s.txt' % (str, str_file_name)
cmd_op = self.get_ssh_cmd_output(myCmd)
source_path = '/tmp/vrouter_logs/%s.txt' % (str_file_name)
dest_path = '%s/vrouter_logs/%s.txt' % (self._parent_dir,
str_file_name)
if not self.do_ftp(source_path, dest_path):
print('\nCopying file %s : Failed' % source_path)
self.get_per_vrf_logs()
self.get_virsh_individual_stats()
def mailStringToAdmin(subject, str):
try:
if "Darwin" in os.popen("uname").read():
return
import mailer
str = str.replace("\n", "<br/>").replace(" ", " ")
msg = mailer.GenerateMessage("NewsRivr Console Error", "*****@*****.**", "mailStringToAdmin", "*****@*****.**", "*****@*****.**", "*****@*****.**", subject, str, str, [])
result = mailer.SendMessage("*****@*****.**", ["*****@*****.**"], msg)
return "True"
except:
pass
def mailStringToAdmin(subject, str):
try:
if "Darwin" in os.popen("uname").read():
return
import mailer
str = str.replace("\n", "<br/>").replace(" ", " ")
msg = mailer.GenerateMessage("NewsRivr Console Error",
"*****@*****.**",
"mailStringToAdmin", "*****@*****.**",
"*****@*****.**",
"*****@*****.**", subject, str, str,
[])
result = mailer.SendMessage("*****@*****.**",
["*****@*****.**"], msg)
return "True"
except:
pass
def route_redirect_next_page():
"""
This is the preferred way of sending a user to the next page.
:return:
"""
if not request is None and not request.referrer is None:
currentPage = str.replace(str(request.referrer), request.host_url, "")
else:
currentPage = session['currentUrl']
if currentPage == "end":
return redirect(current_app.config["APPLICATION_ROOT"] + "/end")
session['currentUrl'] = page_list.next_path(currentPage)
nextUrl = current_app.config["APPLICATION_ROOT"] + "/" + session[
'currentUrl']
return redirect(nextUrl)
def translate(str):
# Translate sequence
str2 = str.replace('T', 'U')
table = {
'UU': 'F',
'CU': 'L',
'AUG': 'M',
'AU': 'I',
'GU': 'V',
'UC': 'S',
'CC': 'P',
'AC': 'T',
'GC': 'A',
'UA': 'Y',
'UAA': '*',
'UAG': '*',
'CA': 'H',
'CAA': 'Q',
'CAG': 'Q',
'AA': 'N',
'AAA': 'K',
'AAG': 'K',
'GA': 'D',
'GAA': 'E',
'GAG': 'E',
'UG': 'C',
'UGA': '*',
'UGG': 'W',
'CG': 'R',
'AG': 'R',
'GG': 'G'
}
ans = ""
for i in range(0, len(str), 3):
slice = str2[i:i + 3]
if slice[:3] in table:
ans += table[slice[:3]]
else:
ans += table[slice[:2]]
return ans
def tag_split(str):
str = "".join(str)
str = str.replace(", ", ",")
return str.split(",")
def remove_whitespace(str):
return str.replace(' ', '')
def _extract_uuid(text):
text = text[text.find("@key="):-1].replace("@key=", "")
if text.startswith("uuid:"):
text = text.replace("uuid:", "")
return text
# -*- coding: gbk -*-
'''
Created on 2017年5月3日
@author: Administrator
'''
from builtins import str
str="hello world"
print(str[0]) #获取字符串某个位置上的字符
print(str[1:3]) #获取字符串某个区间的字符，不包括指定索引的最后那个
print(str[:3]+"kk") #:3 代表取字符串索引为0 到2 的字符
strTwo=str.replace("world","zks")
print(strTwo)
print(r"\n") #：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符
print(str*2) # * 代表重复输出
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
print(errHTML)
print("------------")
print("abcdef".center(10)) #返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
print("abcdfsab".count("ab"))
print("abcdef".find("bk")) #返回在字符串中索引 如果不存在，返回-1
print("abcdef".isalpha()) #至少有一个字母
def _extract_uuid(text):
text = text[text.find("@key="):-1].replace("@key=", "")
if text.startswith("uuid:"):
text = text.replace("uuid:", "")
return text
def tag_split(str):
str = "".join(str)
str = str.replace(", ", ",")
return str.split(",")
def remove_apostrophe(str):
return str.replace("'", "")
def importieren(self, pfad = None, liste = None, ergaenzungsname = None, anzeigename_ergaenzen = False, nach_unten = False, force_gruppenname = None, force_scale = None, DBschema_erweitern = True):
# Der Username der verwendet werden soll
if len(auth_user_global) > 0: # Ist belegt
auth_user = auth_user_global[0]
else:
auth_user = None
self.iface.layerTreeView().setCurrentLayer(None) # None entspricht einem Null Pointer -> Auswahl wird entfernt -> nicht ausgewählt
# Wird in der Regel verwendet wenn
# Gemeindespezifische Daten geladen werden
# zwecks Übersichtlichkeit
self.anzeigename_aendern = anzeigename_ergaenzen
self.gruppen_erg_name = ergaenzungsname # oberste Gruppe/Layer wird mit diesem Namen ergänzt!
if pfad == "":
return
# Das Qgis Projektfile ist ein XML und wird
# hier eingelesen
try:
#pfad = 'd:/delme.qgs'
#xml = file(pfad).read()
#QtWidgets.QMessageBox.about(None, "Fehler", str(locale.getpreferredencoding()))
project_file = open(pfad,'r',-1,'UTF8')
xml = project_file.read()
d = QtXml.QDomDocument()
d.setContent(xml)
except IOError:
QtWidgets.QMessageBox.about(None, "Fehler", "QGIS Projektdatei " + pfad + " nicht gefunden!")
return
# Die gewünschten Tagelemente aus dem XML herauslesen
self.maps = d.elementsByTagName("maplayer")
self.legends = d.elementsByTagName("legendlayer")
self.gruppen = d.elementsByTagName("legendgroup")
self.lyr = None
self.joinlayerid = None
#Zuerst den aktuellen Pfad auf dem
#Qgis steht auslesen (kann z.B. ein lokaler Pfad sein
#von dem ein Projekt geladen wird
CurrentPath = QgsProject.instance().fileName()
#Dann auf den jeweiligen Pfad setzen, von dem geladen wird. Sonst kann kein Projekt
#mit absoluten Pfaden abgespeichert werden (für Layer die mit dem
#VogisMenü geladen werden)
QgsProject.instance().setFileName(pfad)
#falls es länger dauert, ein kurzes Infofenster
#für den Anwender
progressi = QtWidgets.QProgressDialog('Lade Daten','Abbrechen',0,self.maps.length())
progressi.setFixedSize(350,90)
btnCancel = QtWidgets.QPushButton()
btnCancel.setText('Abbrechen')
btnCancel.setFixedSize(70,30)
progressi.setCancelButton(btnCancel)
progressi.setWindowModality(1)
#Schleife geht alle Layer die in der Legende aufscheinen durch. Hier
#ist nämlich die reihenfolge festgelegt, wie sie in Qgis dargestellt werden
#Diese Schleife brauch ich nur für die richtige Reihenfolge
#der importierten Layer in Qgis
zaehler = 0 # der Zähler für die Anzahl der geladenen Layer
j = 0
#for j in range(self.legends.length(),-1,-1):
for j in range(self.legends.length()):
# Schleife geht alle Layer die in der maplayer tags aufscheinen durch
# dort ist nämlich die wirkliche Information für die Darstellung im
# Qgis. Also wird zuerst der Layer per ID in der Obigen
# Schleife ausgewählt und dann in dieser Schleife im maplayertag
# identifiziert
# self.lyr=None
for i in range(self.maps.length()):
# prüfen ob der jeweilige layer nicht schon geladen ist. um das zu tun
# müssen wir im vogis projektimport die identifikation über
# die layerid tag machen. berücksichtigt werden muß auch
# ob die layerid durch den ergaenzungsnamen erweitert wurde!!
quelli = self.maps.item(i).namedItem("id").firstChild().toText().data()
laden = True
lyr_tmp = None
for lyr_tmp in QgsProject.instance().mapLayers(): #alle bereits geladenen Layer durchgehen -> Dictionary
#QtWidgets.QMessageBox.about(None, "Fehler", str(lyr_tmp))
if (ergaenzungsname == None) and (lyr_tmp == quelli): #Treffer: der Layer ist schon geladen
laden = False
if (ergaenzungsname != None) and (lyr_tmp == quelli + ergaenzungsname): #Treffer: der Layer ist schon geladen
laden = False
#Die Layerid ist in den legend tags und maplayer tags gleich
#so kann ein layer genau identifiziert werden. ist laden zudem True
#gehts also weiter
if (self.maps.item(i).namedItem("id").firstChild().toText().data() == self.legends.item(j).namedItem("filegroup").namedItem("legendlayerfile").attributes().namedItem("layerid").nodeValue()) and laden:
#ACHTUNG: Wieder aktivieren!!!!!!!!!!
# wenn nur ein Teil der Layer eines Projekts geladen werden sollen. Die Liste enthält die
# Namen dieser Layer
if liste != None:
brake_val = True
for nd in range(len(liste)):
if liste[nd] == self.legends.item(j).attributes().namedItem("name").nodeValue():
brake_val = False
break
if brake_val:
continue # Nächster Layer, ist nicht auf der Liste
# prüfen, ob der jeweilige Layer eine oder mehrere Jointabelle(n) verwendet
self.joinlayerid = ''
for sj in range(self.maps.item(i).namedItem("vectorjoins").childNodes().length()):
# leider muss ich dann nochmals alles durchgehen....
for lj in range(self.maps.length()):
if (self.maps.item(lj).namedItem("id").firstChild().toText().data() == self.maps.item(i).namedItem("vectorjoins").childNodes().item(sj).attributes().namedItem('joinLayerId').nodeValue()):
self.joinlayerid = self.maps.item(i).namedItem("vectorjoins").childNodes().item(sj).attributes().namedItem('joinLayerId').nodeValue()
#ACHTUNG: unbedingt den nodeValue der ID ändern wenn Gemeindeweise
#geladen wird (DKM) Da in den Qgis Projekten der Gemeinden die jeweilig ID des Layers
#der Einfachheit halber ident ist, würde so qgis den Layer nicht importieren!!!
#So wie der Layername in der Darstellung geändert wird wird auch die ID des Nodes VOR
#dem Laden geändert, damit Qgis das dann so übernimmt!!
noddi = self.maps.item(i).namedItem("id")
if ergaenzungsname != None:
noddi.firstChild().setNodeValue(noddi.firstChild().nodeValue() + ergaenzungsname)
#Abhängig von der vogisini wird das Encoding
#aus der Projektdatei genommen oder CPG datei oder
#wird auf System gesetzt
#ist self.vogisEncoding == project dann werden die Einstellungen des Projekt verwendet
base_name = os.path.dirname(pfad) + '/' + os.path.basename(self.maps.item(i).namedItem("datasource").firstChild().nodeValue())
# Achtung, zwischen absolutem und relativem Pfad unterscheiden
if len(os.path.dirname(self.maps.item(i).namedItem("datasource").firstChild().nodeValue())) < 2: # relativer Pfad im QGIS Projekt!
base_name = os.path.dirname(pfad) + '/' + os.path.basename(self.maps.item(i).namedItem("datasource").firstChild().nodeValue())
else: # absoluter Pfad im QGIS Projekt!
base_name = self.maps.item(i).namedItem("datasource").firstChild().nodeValue()
if vogisEncoding_global[0] == 'menue': # entweder CPG datei oder System setzen
try: # gibts ein cpg datei
datei = open(os.path.splitext(base_name)[0] + '.cpg','r')
codierung_string = datei.read()
datei.close()
self.maps.item(i).namedItem("provider").attributes().namedItem('encoding').setNodeValue(codierung_string)
except IOError: # Es wird der Wert System zugewiesen
self.maps.item(i).namedItem("provider").attributes().namedItem('encoding').setNodeValue('System')
# unbedingt ALLES DESELEKTIEREN, sonst Probleme mit der Reihenfolge
self.iface.layerTreeView().setCurrentLayer(None) # None entspricht einem Null Pointer -> Auswahl wird entfernt -> nicht ausgewählt
nv_ds = ''
nv_provider = ''
nv_encoding = ''
#############################################################################
# Das Umschalten der Vektordaten auf die Geodatenbank - unter Bedingungen
# es darf kein Layer aus einer Geodatenbank hier verwurschtelt werden
#############################################################################
if self.maps.item(i).attributes().namedItem('type').nodeValue() == 'vector' and vogisDb_global[0] != 'filesystem geodaten' and self.maps.item(i).namedItem("datasource").firstChild().nodeValue().find('host') < 0:
tablename = self.maps.item(i).namedItem("datasource").firstChild().nodeValue()
sql = ''
rc=[]
db_ogr = ''
# prüfen ob der layer eine shape datenquelle ist
# und ob ein subset definiert ist
if tablename.find('.shp') > 0 and (tablename.lower().find('subset') > 0 or tablename.lower().find('SUBSET') > 0 or tablename.lower().find('Subset') > 0):
rc = textfilter_subset(self.maps.item(i).namedItem("datasource").firstChild().nodeValue())
tablename = rc[0]
sql = rc[1]
db_ogr = rc[0]
else:
tablename = os.path.basename(self.maps.item(i).namedItem("datasource").firstChild().nodeValue()).split('.shp')[0]
db_ogr = tablename
if ergaenzungsname != None and DBschema_erweitern:
tablename = str.lower('\"' + ergaenzungsname + '\".\"' + tablename + '\"')
else:
tablename = str.lower('\"vorarlberg".\"' + tablename + '\"')
# Sonderzeichen berücksichtigen!
tablename = tablename.replace(('ä'),'ae')
tablename = tablename.replace(('Ä'),'Ae')
tablename = tablename.replace(('ö'),'oe')
tablename = tablename.replace(('Ö'),'Oe')
tablename = tablename.replace(('ü'),'ue')
tablename = tablename.replace(('Ü'),'Ue')
tablename = tablename.replace(('ß'),'ss')
tablename = tablename.replace('. ','_')
################################################
# Geometriespalte bestimmen -- geht nur mit OGR
param_list = str.split(vogisDb_global[0])
host = ''
dbname=''
port=''
for param in param_list:
if str.find(param,'dbname') >= 0:
dbname = str.replace(param,'dbname=','')
elif str.find(param,'host=') >= 0:
host = str.replace(param,'host=','')
elif str.find(param,'port=') >= 0:
port = str.replace(param,'port=','')
try:
if auth_user == None:
outputdb = ogr.Open('pg: host=' + host + ' dbname=' + dbname + ' schemas=vorarlberg' + ' port=' + port)
else:
outputdb = ogr.Open('pg: host=' + host + ' dbname=' + dbname + ' schemas=vorarlberg' + ' port=' + port + ' user='******'the_geom'
##################################################
# Geometriespalte Ende
if self.maps.item(i).namedItem("datasource").firstChild().nodeValue().find('ogc_fid') > 0:
# Achtung, das Attribut user darf nicht zwingend immer nur klein sein -> Siehe Usermapping in der Doku
if auth_user == None:
dbpath = str.lower(vogisDb_global[0] + ' sslmode=disable table=' + tablename + ' (' + geom_column + ') sql') + sql
else:
dbpath = str.lower(vogisDb_global[0]) + ' user='******' sslmode=disable table=' + tablename + ' (' + geom_column + ') sql') + sql
else:
# Achtung, das Attribut user darf nicht zwingend immer nur klein sein -> Siehe Usermapping in der Doku
if auth_user == None:
dbpath = str.lower(vogisDb_global[0] + ' sslmode=disable key=ogc_fid table=' + tablename + ' (' + geom_column + ') sql') + sql
else:
dbpath = str.lower(vogisDb_global[0]) + ' user='******' sslmode=disable key=ogc_fid table=' + tablename + ' (' + geom_column + ') sql') + sql
nv_ds = self.maps.item(i).namedItem("datasource").firstChild().nodeValue()
nv_provider = self.maps.item(i).namedItem("provider").firstChild().nodeValue()
nv_encoding = self.maps.item(i).namedItem("provider").attributes().namedItem('encoding').nodeValue()
self.maps.item(i).namedItem("datasource").firstChild().setNodeValue(dbpath)
self.maps.item(i).namedItem("provider").firstChild().setNodeValue('postgres')
self.maps.item(i).namedItem("provider").attributes().namedItem('encoding').setNodeValue('UTF-8')
if os.path.abspath(os.path.dirname(__file__)) != path_global[0]:
return
# Layer einlesen!
proj_read = QgsProject.instance().readLayer(self.maps.item(i))
# Der Fortschrittsbalken
progressi.setValue(j)
progressi.forceShow()
if progressi.wasCanceled():
break
#QtGui.QMessageBox.about(None, "Achtung", str(proj_read))
if not proj_read and vogisDb_global[0] == 'filesystem geodaten': # hier wird der Layer geladen und gemäß den Eintragungen
# der DomNode auch gerendert und dargestellt
QtWidgets.QMessageBox.about(None, "Achtung", "Layer " + self.legends.item(j).attributes().namedItem("name").nodeValue() + " nicht gefunden!")
continue
elif not proj_read and vogisDb_global[0] != 'filesystem geodaten': # Probieren auf Filesystem umzuschalten
QtWidgets.QMessageBox.about(None, "Achtung", "Layer - " + self.legends.item(j).attributes().namedItem("name").nodeValue() + " - in der Datenbank nicht gefunden - es wird aufs Filesystem umgeschaltet")
self.maps.item(i).namedItem("datasource").firstChild().setNodeValue(nv_ds)
self.maps.item(i).namedItem("provider").firstChild().setNodeValue(nv_provider)
self.maps.item(i).namedItem("provider").attributes().namedItem(nv_encoding)
if not QgsProject.instance().readLayer(self.maps.item(i)): #Trotzdem nicht gefunden, wir geben auf
QtWidgets.QMessageBox.about(None, "Achtung", "Layer " + self.legends.item(j).attributes().namedItem("name").nodeValue() + " nicht gefunden!")
continue
# den Anzeigenamen im Qgis ebenfalls ändern
# dazu zuerst den richtigen Layer anhand der Layerid auswählen
# leginterface = self.iface.legendInterface()
#for lyr_tmp in leginterface.layers():
for lyr_tmp in QgsProject.instance().mapLayers(): #alle bereits geladenen Layer durchgehen -> Dictionary
if lyr_tmp == noddi.firstChild().nodeValue():
self.lyr = QgsProject.instance().mapLayers()[lyr_tmp]
if force_scale != None:
self.lyr.setMaximumScale(25000)
self.lyr.setScaleBasedVisibility(True)
#Abhängig von der vogisini wird das KBS
#aus der Projektdatei genommen oder aus dem *.prj File
if vogisKBS_global[0] == 'menue':
#Koordinatenbezugssystem aus dem prj file holen, wenn vorhanden,
#und von dort zuweisen (die Projekteinstellung überschreiben)
try:
datei = open(os.path.splitext(self.lyr.source())[0] + '.prj','r')
bezugssystem_string = datei.read()
#falls kein sauberer EPSG String, machen wir eine Zuweisung für unser 31254
if (re.search('MGI\D+Austria\D+GK\D+West',bezugssystem_string, re.I)) != None: #Arcgis macht keinen sauberen EPSG String
bezugssystem_crs = QgsCoordinateReferenceSystem()
bezugssystem_crs.createFromSrid(31254)
else:
bezugssystem_crs = QgsCoordinateReferenceSystem(bezugssystem_string)
datei.close()
self.lyr.setCrs(bezugssystem_crs)
except IOError:
pass
#dann in der Applikation registrieren
#QgsMapLayerRegistry.instance().addMapLayer(self.lyr)
# gejointe Tabellen brauchen eine Spezialbehandlung: Joininfo wird
# ausgelesen, dann der join gelöscht und erst wenn alles geladen wurde
# wieder neu erstellt. Sonst kann es Probleme geben! unterstütz
# werden beleibig viele layer mit beliebig vielen joins
# es handelt sich um einen layer mir midestens einem eingetragenen join
single_lyr_join = lyr_join() # eigenes struktur objekt instanzieren
if not self.joinlayerid == '': # checken ob für den layer mindestens ein join eingetragen ist
single_lyr_join.joinlayer = self.lyr
single_lyr_join.joininfo = self.lyr.vectorJoins()
self.joinliste.append(single_lyr_join) # eine liste mit joinlayern und deren joininfo führen
for rem_join in self.lyr.vectorJoins(): # für den joinlayer die joins entfernen - es können merhere sein
kasperle = rem_join.joinLayerId
self.lyr.removeJoin(str(rem_join.joinLayerId))
#Und nun noch den Layernamen für die Darstellung
#im Qgis ergänzen. Siehe oben, bei gemeindeweisem Laden
if (ergaenzungsname != None) and (self.lyr != None) and self.anzeigename_aendern: # noch ein boolean wegen der wasserwirtschaft!!
if not (self.lyr.name().find(ergaenzungsname) > -1): # ACHTUNG: Sonst wird bei wiederholtem klicken der Name nochmal rangehängt
if self.lyr.name().find("(a)") > -1:
aktname = str.strip((self.lyr.name().rstrip("(a)"))) + "-" + ergaenzungsname + " (a)"
self.lyr.setName(aktname)
else:
aktname = str.strip(self.lyr.name())+ "-" + ergaenzungsname
self.lyr.setName(aktname)
# abschließend schauen ob der aktiviert ist
if (self.legends.item(j).attributes().namedItem("checked").nodeValue() == "Qt::Unchecked") and not (self.lyr is None):
#leginterface.setLayerVisible(self.lyr,False)
lyr_tree = QgsProject.instance().layerTreeRoot().findLayer(self.lyr)
lyr_tree.setItemVisibilityChecked(False)
index = QgsProject.instance().layerTreeRoot()
zwetsch =QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id())
dummy = zwetsch.clone()
# Die Layer die später geladen werden müssen
# auch weiter unte in der Legende sein Reihenfolge)
# das wird mit der Variable zaehler gesteuert
# QGIS höher 2.6
index_ins = index_zuweisen(self.legends.item(j).attributes().namedItem("name").nodeValue(),self.legends.item(j).parentNode())
index.insertChildNode(-1,dummy)
zaehler = zaehler + 1
zwetsch.parent().removeChildNode(zwetsch)
# sonst gibts probleme in der Reihenfolge
# wenn gruppen und layer im top level vermischt
if not (self.legends.item(j).parentNode().nodeName() == "legendgroup") and (force_gruppenname is None):
zwetsch =QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id())
dummy = zwetsch.clone()
index.insertChildNode(index_ins,dummy)
zwetsch.parent().removeChildNode(zwetsch)
#abschließend schauen ob der Layer aufgeklappt ist
#und das flag setzen
if (self.legends.item(j).attributes().namedItem("open").nodeValue() == "false") and not (self.lyr is None):
dummy.setExpanded(False)
elif (self.legends.item(j).attributes().namedItem("open").nodeValue() == "true") and not (self.lyr is None):
dummy.setExpanded(True)
# hier könnte abgebrochen werden, wenn die layer einfach
# nur reingeladen werden OHNE in Gruppenlyer abgelegt zu werden
# continue
#######################################################
# hier beginnt der Programmteil der die Gruppenlayer
# behandelt - entweder wenn im Projektfile definiert
# oder einfach wenn es im Menü
# erwünscht wird
#######################################################
if (self.legends.item(j).parentNode().nodeName() == "legendgroup") or not (force_gruppenname is None):
self.gruppe_vorhanden = False
#ACHTUNG: Layername und direkt übergeordneter Gruppenname
#müssen sich unterscheiden, sonst kommts zu einem Fehler. Sollts
#dennoch mal vorkommen, wird es hier abgefangen
if self.legends.item(j).parentNode().attributes().namedItem("name").nodeValue() == self.legends.item(j).attributes().namedItem("name").nodeValue():
aktname = self.lyr.name()
self.lyr.setName(aktname+"_")
#prüfen ob die Gruppe schon angelegt ist
grp_name = self.legends.item(j).parentNode().attributes().namedItem("name").nodeValue() #Name der Gruppe aus dem QGS Projektfile
grp_obj = QgsProject.instance().layerTreeRoot().findGroup(grp_name)
if (isinstance(grp_obj,QgsLayerTreeGroup)) and (not (grp_obj is None)):
self.gruppe_vorhanden = True
grp_name = force_gruppenname #Name ist übergeben worden
grp_obj = QgsProject.instance().layerTreeRoot().findGroup(grp_name)
if (isinstance(grp_obj,QgsLayerTreeGroup)) and (not (grp_obj is None)):
self.gruppe_vorhanden = True
#########################################################
# Gruppenlayer aus Projektdatei
#########################################################
if self.legends.item(j).parentNode().attributes().namedItem("name").nodeValue() != "" and self.legends.item(j).parentNode().nodeName() == "legendgroup":
QgsLayerTreeRegistryBridge(QgsProject.instance().layerTreeRoot(),QgsProject.instance())
kind = self.legends.item(j).parentNode()
gruppen_hierarchie = pos_gruppe()
gruppen_liste = []
while (kind.nodeName() == "legendgroup"):
gruppen_hierarchie.name = kind.attributes().namedItem("name").nodeValue() # der name der dem layer unmittelbar übergeordnete Gruppe: Ebene
gruppen_hierarchie.index = index_zuweisen(kind.attributes().namedItem("name").nodeValue(),kind.parentNode()) # Index der Darstellungsreihenfolge der Gruppe in ihrer Hierarchie
gruppen_hierarchie.ex = kind.attributes().namedItem("open").nodeValue()
gruppen_hierarchie.ch = kind.attributes().namedItem("checked").nodeValue()
gruppen_liste.append(copy.deepcopy(gruppen_hierarchie)) # ACHTUNG: Referenz!!
kind = kind.parentNode()
# grp enthält das qtreewidgetitem Objekt der Gruppe!, in die der geladene
# Layer verschoben werden soll!
grp = sublayer(QgsProject.instance().layerTreeRoot(),gruppen_liste, self.gruppen_erg_name, nach_unten, anzeigename_ergaenzen)[0] #sollten es mehrere sein, immer nur die erste nehmen - siehe Erklärung beim Sub selbst
zwtsch = QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id())
dummy = zwtsch.clone()
if not (isinstance(grp,QgsLayerTreeGroup)) or grp is None:
QtWidgets.QMessageBox.about(None, "ACHTUNG","Anlegen der Gruppe gescheitert")
break
index_layer = index_zuweisen(self.legends.item(j).attributes().namedItem("name").nodeValue(),self.legends.item(j).parentNode())
# QtGui.QMessageBox.about(None, "LayeriD", str(dummy.layerId()))
grp.insertChildNode(index_layer,dummy)
zwtsch.parent().removeChildNode(zwtsch) # zwilling entfernen!
##########################################################
# hier Endet der Teil der Gruppenlayer aus Projektdatei!!
#########################################################
letzterplatz = False #Flagvariable ermittelt ob die Gruppe ganz nach unten gehört
#die gruppe in die der layer eingebettet ist kommt nicht aus
#einem projekt, sondern wird erzwungen. hier gibts allerdings
#nur eine ebene (was das ganze einfacher macht)
if (not force_gruppenname is None):
# gruppe anlegen
gruppen_hierarchie = pos_gruppe()
gruppen_hierarchie.name = force_gruppenname
# grp = sublayer(QgsProject.instance().layerTreeRoot(),leginterface,[gruppen_hierarchie])[0]
grp = sublayer(QgsProject.instance().layerTreeRoot(),[gruppen_hierarchie])[0]
zwtsch = QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id()) #der geladene layer
dummy = zwtsch.clone()
# wiviele layer sind in der gruppe bereits vorhanden?
# baum = QgsLayerTreeModel(grp)
# anzahl_top_level_eintraege = baum.rowCount()
baum = grp.findLayers()
anzahl_top_level_eintraege = len(baum)
baum = None # Sonst Absturz bei grp.parent().removeChildNode(grp) da baum auf ein Nichts refenrenziert!
# den neuen ganz hinten einsetzen
grp.insertChildNode(anzahl_top_level_eintraege,dummy)
zwtsch.parent().removeChildNode(zwtsch)
grp.setExpanded(False)
if nach_unten: # ganz nach unten mit der gefüllten Gruppe, wenn das Flag gesetzt ist
if not self.gruppe_vorhanden:
dummy = grp.clone()
QgsProject.instance().layerTreeRoot().insertChildNode(-1,dummy)
grp.parent().removeChildNode(grp)
else: # die Layer werden NICHT in einen self.gruppenlayer geladen
# sollen aber nach unten verschoben werden
if nach_unten:
# wiviele layer sind in der gruppe bereits vorhanden?
baum = QgsLayerTreeModel(QgsProject.instance().layerTreeRoot())
anzahl_top_level_eintraege = baum.rowCount()
baum = None # Sonst Absturz bei grp.parent().removeChildNode(grp) da baum auf ein Nichts refenrenziert!
zwtsch = QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id()) #der geladene layer
dummy = zwtsch.clone()
# den neuen ganz hinten einsetzen
QgsProject.instance().layerTreeRoot().insertChildNode(anzahl_top_level_eintraege,dummy)
zwtsch.parent().removeChildNode(zwtsch)
# abschließend schauen ob der Layer aufgeklappt ist
# und das flag setzen - beim Verschieben in die Gruppenlayer
# verändert sich das nämlich manchmal...
if (self.legends.item(j).attributes().namedItem("open").nodeValue() == "false") and not (self.lyr is None):
dummy.setExpanded(False)
elif (self.legends.item(j).attributes().namedItem("open").nodeValue() == "true") and not (self.lyr is None):
dummy.setExpanded(True)
# der nachfolgende Code erzwingt eine Aktualisierung
# der Legende und des MapWindow
# Ansonsten kanns im Mapwindow Darstellungsprobleme geben! Wieso??
if not self.lyr is None:
anzeigename = self.lyr.name()
self.lyr.setName(anzeigename+" ")
self.lyr.setName(anzeigename)
else:
QtWidgets.QMessageBox.about(None, "Achtung", "Layer " + self.legends.item(j).attributes().namedItem("name").nodeValue() + " nicht gefunden!")
# unbedingt ALLES DEselektieren, sonst Probleme mit Reihenfolge
self.iface.layerTreeView().setCurrentLayer(None) # None entspricht einem Null Pointer -> Auswahl wird entfernt -> nicht ausgewählt
#Unbedingt zurücksetzen sonst kanns beim wiederholten
#laden des gleichen Projektfiles einen Fehler geben:
#wenn nämlich die Schleife erneut beginnt, nicht lädt und self.lyr
#beim vorherigen laden steht!
self.lyr = None
# und weiter in der Schleife!
# UNBEDINGT am Schluss QGis wieder auf den usprünglichen
# Pfad zurücksetzen
QgsProject.instance().setFileName(CurrentPath)
#ACHTUNG: Aus irgendeinem Grund gibts Probleme mit den Gruppenlayer: Wenn innerhalb der so angelegten Gruppen
# ein Layer ausgewählt wird, gibts beim Laden danach einen Fehler. Es MUSS deshalb der oberste Eintrag
# der Legende vor allem Laden als Aktueller Layer gesetzt werden!!!
#Objekte besser löschen
self.legends = None
self.legendTree = None
self.maps = None
self.legends = None
self.gruppen = None
######################################################################
# Abschlussprüfung: sind alle da
#prüfen ob alle Layer der Liste geladen wurden
#das ist notwendig, da ja beim Projektladen alles passen kann aber
#ein Layer nicht vorhanden ist
######################################################################
fehler = 0
layerzaehler = 0
# Weg mit dem Fortschrittsbalken
# self.info.close()
if liste != None: #wenn nur ein Teil der Layer eines Projekts geladen wurde. Die Liste enthält die
#Namen dieser Layer
for nd in range(len(liste)):
for lyr_tmp_id in QgsProject.instance().mapLayers(): #alle bereits geladenen Layer durchgehen -> Dictionary
lyr_tmp = QgsProject.instance().mapLayer(lyr_tmp_id)
# Unbedingt die optionale Änderung des
# Anzeigenamens (z.B. DKM) mitberücksichtigen!)
if (ergaenzungsname != None) and self.anzeigename_aendern:
if liste[nd] + "-" + ergaenzungsname == lyr_tmp.name():
layerzaehler = layerzaehler +1
elif liste[nd].rstrip(" (a)") + "-" + ergaenzungsname + ' (a)' == lyr_tmp.name():
layerzaehler = layerzaehler +1
else:
if liste[nd] == lyr_tmp.name():
layerzaehler = layerzaehler +1
# ACHTUNG: Wurden nicht alle in der Liste (fürs importieren übergebne Layerliste mit Layernamen) angeführten Layer
# anhand des Layernamensim Projekt gefunden gibts
# hier noch eine Fehlermeldung
if not liste is None:
if len(liste) > layerzaehler: #Ints! Dann wurde was nicht geladen
QtWidgets.QMessageBox.about(None, "Achtung", "Nicht alle Layer aus " + pfad + " konnte(n) geladen werden!!")
# gejointe Relationen wiederherstellen
# aber erst ganz am Schluss!!
for singlejoin in self.joinliste:
for singlejoininfo in singlejoin.joininfo:
singlejoin.joinlayer.addJoin(singlejoininfo)
def convert_data_to_c(self, label, width, data):
""" Generate C formated data """
logging.info("convert_data_to_c %s %d %s" % (label, width, data))
first = True
is_string = False
elements = 0
data_ctype = {1: 'db', 2: 'dw', 4: 'dd', 8: 'dq'}[width]
r = [""]
rh = []
base = {
1: 0x100,
2: 0x10000,
4: 0x100000000,
8: 0x10000000000000000
}[width]
for v in data:
v = v.strip()
if width == 1 and (v[0] in ["'", '"']):
if v[-1] not in ["'", '"']:
raise Exception("invalid string %s" % v)
if width > 1:
raise Exception("string with data width more than 1"
) #we could allow it :)
v = str.replace(v, "''", "'")
for i in range(1, len(v) - 1):
r.append(v[i])
is_string = True
continue
logging.debug("is_string %d" % is_string)
logging.debug("v ~%s~" % v)
'''
if is_string and v.isdigit():
v = "'\\" +str(hex(int(v)))[1:] + "'"
'''
m = re.match(r'(\w+)\s+dup\s*\((\s*\S+\s*)\)', v)
if m is not None:
#we should parse that
n = self.parse_int(m.group(1))
value = m.group(2)
value = value.strip()
if value == '?':
value = 0
else:
value = self.parse_int(value)
#print "n = %d value = %d" %(n, value)
for i in range(0, n):
v = value
r.append(v)
elements += n
first = False
continue
try:
elements += 1
#print "1: ~%s~" %v
v = v.strip()
#print "2: ~%s~" %v
if v == '?':
v = '0'
v = self.parse_int(v)
#print "3: ~%s~" %v
#print "4: ~%s~" %v
if v < 0: # negative values
#data_ctype = {1: 'int8_t', 2: 'int16_t', 4: 'int32_t'}[width]
v += base
#print "5: ~%s~" %v
except:
#global name
#traceback.print_stack(file=sys.stdout)
#print "global/expr: ~%s~" %v
vv = v.split()
logging.debug(vv)
if vv[0] == "offset": # pointer
data_ctype = "dw"
#v = "&" + vv[1] + " - &" + self.segment
v = vv[1]
#r.append(v);
logging.debug("global/expr: ~%s~" % v)
try:
v = str.replace(v, 'offset ', '')
v = re.sub(r'@', "arb", v)
v = self.convert_data(v, base)
except KeyError:
logging.warning("unknown address %s" % (v))
logging.warning(self.c_data)
logging.warning(r)
logging.warning(len(self.c_data) + len(r))
self.link_later.append((len(self.c_data) + len(r), v))
v = 0
r.append(v)
first = False
cur_data_type = 0
if is_string:
if len(r) - 1 >= 1 and r[-1] == 0:
cur_data_type = 1 # 0 terminated string
else:
cur_data_type = 2 # array string
else:
cur_data_type = 3 # number
if elements > 1:
cur_data_type = 4 # array of numbers
# if prev array of numbers and current is a number and empty label and current data type equal to previous
#if self.prev_data_type == 4 and cur_data_type == 3 and len(label)==0 and data_ctype == self.prev_data_ctype: # if no label and it was same size and number or array
# cur_data_type = 4 # array of numbers
#print "current data type = %d current data c type = %s" %(cur_data_type, data_ctype)
logging.debug("current data type = %d current data c type = %s" %
(cur_data_type, data_ctype))
'''
# if prev data type was set and data format has changed or data type has changed or there is a label or it was 0-term string or it was number
if (self.prev_data_type != 0 and (cur_data_type != self.prev_data_type or data_ctype != self.prev_data_ctype)) or len(label) or self.prev_data_type == 1 or self.prev_data_type == 3:
# if it was array of numbers or array string
if self.prev_data_type == 4 or self.prev_data_type == 2:
vv += "}"
vv += ";\n"
else:
# if prev data type was set and it is not a string
if self.prev_data_type != 0 and (cur_data_type == 2 or cur_data_type == 3 or cur_data_type == 4):
vv += ","
'''
if len(label) == 0:
self.dummy_enum += 1
label = "dummy" + str(self.dummy_enum)
vh = ""
vc = ""
if cur_data_type == 1: # 0 terminated string
vh = "char " + label + "[" + str(len(r) - 1) + "]"
elif cur_data_type == 2: # array string
vh = "char " + label + "[" + str(len(r) - 1) + "]"
vc = "{"
elif cur_data_type == 3: # number
vh = data_ctype + " " + label
elif cur_data_type == 4: # array
vh = data_ctype + " " + label + "[" + str(elements) + "]"
vc = "{"
if cur_data_type == 1: # string
vv = "\""
for i in range(1, len(r) - 1):
if isinstance(r[i], int):
if r[i] == 13:
vv += r"\r"
elif r[i] == 10:
vv += r"\n"
elif r[i] == "\\":
vv += '\\\\'
else:
vv += chr(r[i])
else:
vv += r[i]
vv += "\""
r = [""]
r.append(vv)
elif cur_data_type == 2: # array of char
vv = ""
logging.debug(r)
for i in range(1, len(r)):
if isinstance(r[i], int):
if r[i] == 13:
vv += r"'\r'"
elif r[i] == 10:
vv += r"'\n'"
else:
vv += str(r[i])
elif isinstance(r[i], str):
#print "~~ " + r[i] + str(ord(r[i]))
if r[i] in ["\'", '\"', '\\']:
#print "aaa"
r[i] = "\\" + r[i]
elif ord(r[i]) > 127: # \
r[i] = hex(ord(r[i]))
r[i] = '\\' + r[i][1:]
vv += "'" + r[i] + "'"
if i != len(r) - 1:
vv += ","
r = [""]
r.append(vv)
elif cur_data_type == 3: # number
r[1] = str(r[1])
#r = []
#r.append(vv)
elif cur_data_type == 4: # array of numbers
#vv = ""
for i in range(1, len(r)):
r[i] = str(r[i])
if i != len(r) - 1:
r[i] += ","
#r = []
#r.append(vv)
r[0] = vc
rh.insert(0, vh)
# if it was array of numbers or array string
if cur_data_type == 4 or cur_data_type == 2:
r.append("}")
r.append(", // " + label + "\n")
rh.append(";\n")
logging.debug(r)
logging.debug(rh)
logging.info("returning")
self.prev_data_type = cur_data_type
self.prev_data_ctype = data_ctype
self.data_started = True
return r, rh, elements
