From 7c9852b4d0ca9d28ea46233f04dddcfa7589a3e8 Mon Sep 17 00:00:00 2001 From: spertl Date: Mon, 26 Aug 2024 04:50:37 +0000 Subject: [PATCH] upload --- upload/KanalTools.py | 781 ++++++++++++++++++++++++++++++++++++++++ upload/icon_txt.png | Bin 0 -> 1281 bytes upload/metadata.txt | 47 +++ upload/plugin_upload.py | 111 ++++++ upload/qgs_interface.py | 33 ++ 5 files changed, 972 insertions(+) create mode 100644 upload/KanalTools.py create mode 100644 upload/icon_txt.png create mode 100644 upload/metadata.txt create mode 100644 upload/plugin_upload.py create mode 100644 upload/qgs_interface.py diff --git a/upload/KanalTools.py b/upload/KanalTools.py new file mode 100644 index 0000000..2d6a5bb --- /dev/null +++ b/upload/KanalTools.py @@ -0,0 +1,781 @@ +import ezdxf +import pandas as pd +import numpy as np +import networkx as nx +import math +import scipy +import sqlite3 +import subprocess + +TEIGHA_PATH = "C:/Daten/nc/Ingenieurbüro/20 Projekte/Kanalplanung/Teigha File Converter 4.3.2/TeighaFileConverter.exe" + +""" + +Funktionsweise der Kanal_Tools: +Daten mit QGIS aufbereiten +ibp_calc() +ibp_calc_netz() +ibp_calc_hydraulik() + + +""" + + +inp_file = 'D:/Daten/nc/Ingenieurbüro/20 Projekte/Kanalplanung/kanalplanung.gpkg' +md = QgsProviderRegistry.instance().providerMetadata("ogr") +gpkg_con = md.createConnection( inp_file, {}) + + +def ibp_all(): + ibp_calc() + ibp_calc_netz() + ibp_hydraulik() + +## Funktion um einen globalen Layer-Filter zu setzen + +def ibp_filter(filter): + #alle Layer + gpkg_con.executeSql("UPDATE projekt SET aktiv = 0;") + + + #for i in self.iface.mapCanvas().layers(): + # idx = i.fields().indexFromName('ibpprj') + # if idx >= 0: + # i.setSubsetString("ibpprj LIKE '%"+self.act.currentText()+"%'") + + text, ok = QInputDialog().getText(self, "QInputDialog().getText()","User name:", QLineEdit.Normal) + + #for row in QgsProject.instance().mapLayers().values(): + # #if row.name() in ["haltung", "schacht", "rw_einzugsgebiete"]: + # if re.search(r".*kanalplanung.gpkg\|layername=(haltung|schacht|rw_einzugsgebiete).*", row.source()): + # if re.search(r".*kanalplanung.gpkg\|layername=(haltung_sp)", row.source()): + # row.setSubsetString("") + # elif filter != "": + # row.setSubsetString(""""ibpprj" = '{0}'""".format(filter)) + # gpkg_con.executeSql("UPDATE projekt SET aktiv = 1 WHERE nr='{}';".format(filter)) + # else: + # row.setSubsetString("") + +def ibp_calc(): + + query = """UPDATE haltung SET + zul_sch_fid = (SELECT s.fid FROM schacht s WHERE distance(geomfromgpb(s.geom),startpoint(geomfromgpb(haltung.geom))) < 0.05 LIMIT 1), + abl_sch_fid = (SELECT s.fid FROM schacht s WHERE distance(geomfromgpb(s.geom),endpoint(geomfromgpb(haltung.geom))) < 0.05 LIMIT 1);""" + res = gpkg_con.executeSql(query) + + + query = """UPDATE sw_fallrohre SET + (du, dn, anmerkung, kurz) = (SELECT du, dn, anmerkung, kurz FROM config_gegenstaende where config_gegenstaende.gegenstand = sw_fallrohre.gegenstand);""" + res = gpkg_con.executeSql(query) + + query = """UPDATE schacht SET + (ezg_direkt_A, ezg_direkt_Aum, ezg_direkt_Aus) = (SELECT sum(rw_ezg.A), sum(rw_ezg.Aum),sum(rw_ezg.Aus) FROM rw_einzugsgebiete rw_ezg WHERE rw_ezg.schacht_fid = schacht.fid), + (sw_du_sum) = (SELECT sum(swf.du) FROM sw_fallrohre swf WHERE swf.schacht_fid = schacht.fid), + sh = IIF(sh_fix > 0, sh_fix, (SELECT min(sh) FROM ( + SELECT haltung.zul_sh as sh FROM haltung WHERE haltung.zul_sch_fid = schacht.fid and haltung.zul_sh > 0 + UNION + SELECT haltung.abl_sh as sh FROM haltung WHERE haltung.abl_sch_fid = schacht.fid and haltung.abl_sh > 0)));""" + res = gpkg_con.executeSql(query) + + query = """UPDATE schacht SET + ezg_direkt_psi_m = ezg_direkt_Aum/ezg_direkt_A, + ezg_direkt_psi_s = ezg_direkt_Aus/ezg_direkt_A;""" + res = gpkg_con.executeSql(query) + + query = """DROP TABLE IF EXISTS haltung_sp;""" + res = gpkg_con.executeSql(query) + + + query = """CREATE TABLE haltung_sp AS + SELECT + s1z.name, s1a.name, + s2z.name, s2a.name, + a.zul_sch_fid, a.abl_sch_fid, + b.zul_sch_fid, b.abl_sch_fid, + ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)) geometry, + AsText(ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom))) txt, + ifnull(ST_InterpolatePoint(ST_AddMeasure(geomfromgpb(a.geom),0, 1),ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)))*a.c_laenge,0) d1, + ifnull(a.zul_sh - a.c_laenge / (ST_InterpolatePoint(ST_AddMeasure(geomfromgpb(a.geom),0, 1),ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)))*a.c_laenge) * a.gefaelle / 1000,0) h1, + ifnull(ST_InterpolatePoint(ST_AddMeasure(geomfromgpb(b.geom),0, 1),ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)))*b.c_laenge,0) d2, + ifnull(b.zul_sh - b.c_laenge / (ST_InterpolatePoint(ST_AddMeasure(geomfromgpb(b.geom),0, 1),ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom)))*b.c_laenge) * b.gefaelle / 1000,0) h2, + a.di di1, b.di, b.art + FROM + haltung a, haltung b + LEFT JOIN schacht s1z on a.zul_sch_fid = s1z.fid + LEFT JOIN schacht s1a on a.abl_sch_fid = s1a.fid + LEFT JOIN schacht s2z on b.zul_sch_fid = s1z.fid + LEFT JOIN schacht s2a on b.abl_sch_fid = s1z.fid + WHERE + geometry not NULL and + GeometryType(ST_Intersection(GeomfromGPB(a.geom), GeomfromGPB(b.geom))) = "POINT" + and round(d1,2) > 0 and d1 < a.c_laenge;""" + res = gpkg_con.executeSql(query) + + query = """DROP TABLE IF EXISTS haltung_calc_graph;""" + res = gpkg_con.executeSql(query) + + query = """CREATE TABLE haltung_calc_graph AS +WITH RECURSIVE graph(n,sn_fid,en_fid,du_sum,sw_k,Qpump,Qc, Aus, Aum) AS ( + SELECT + h.fid, h.zul_sch_fid, h.abl_sch_fid, + schc.sw_du_sum, schc.sw_k, schc.Qpump, schc.Qc, + schc.ezg_direkt_Aus, schc.ezg_direkt_Aum + FROM haltung h + LEFT join schacht schc on h.zul_sch_fid = schc.fid + UNION + SELECT + n, h.zul_sch_fid, h.abl_sch_fid, + schc.sw_du_sum, schc.sw_k, schc.Qpump, schc.Qc, + schc.ezg_direkt_Aus, schc.ezg_direkt_Aum + FROM graph + LEFT JOIN haltung h on h.abl_sch_fid = graph.sn_fid + LEFT JOIN schacht schc on h.zul_sch_fid = schc.fid + ) +SELECT n fid,sn_fid zul_sch_fid,en_fid abl_sch_fid, + sum(du_sum) du_sum,max(sw_k) sw_k,sum(Qpump) Qpump,sum(Qc) Qc, sum(Aus) Aus, sum(Aum) Aum + FROM graph + +WHERE sn_fid IS NOT NULL and en_fid IS NOT NULL GROUP BY n;""" + res = gpkg_con.executeSql(query) + + query = """UPDATE haltung SET + (du_sum, Qww, Qpump, Qc, Aus, Aum) = + (SELECT + ifnull(g.du_sum,0), + ifnull(g.sw_k*sqrt(g.du_sum),0), + ifnull(g.Qpump,0), + ifnull(g.Qc,0), + ifnull(g.Aus,0), + ifnull(g.Aum,0) + FROM haltung_calc_graph g WHERE g.fid = haltung.fid), + (sw_k, bem_regen) = (SELECT sw_k, rohr_bem_regen FROM projekt WHERE projekt.nr = haltung.ibpprj), + c_laenge = GLength(geomfromgpb(geom)) + ;""" + res = gpkg_con.executeSql(query) + + query = """UPDATE haltung SET + Qsw = ifnull(sw_k * sqrt(du_sum)+Qpump+Qc, 0), + Qrr = ifnull(Aus*bem_regen/10000,0 ), + zul_fuellg = IIF(haltung.art = 'SW', IIF(haltung.Qpump = 0, 0.5, 0.7), IIF(haltung.art='RW',0.9,NULL) );""" + res = gpkg_con.executeSql(query) + + query = """UPDATE haltung SET + Qtot = Qsw + Qrr;""" + res = gpkg_con.executeSql(query) + + query = """UPDATE schacht SET + (ezg_total_Aus, ezg_total_Aum) = (SELECT sum(haltung.Aus), sum(haltung.Aum) FROM haltung WHERE haltung.abl_sch_fid = schacht.fid);""" + res = gpkg_con.executeSql(query) + + + + +## Funktion um einen Schnitt zu erstellen +# Ausgangsdaten-Tabelle: haltung, haltung_sp, schacht, sw_fallrohre +# Ergebnis-Tablle: haltung_calc_hydraulik +def ibp_schnitt(schnitte_filename, hor, fok, schnitte_masstab, schnitte, ibpprj): + mx,my = schnitte_masstab + + graph = nx.DiGraph() + + query = """SELECT + ifnull(zul_sch_fid,0) zul_sch_fid, + ifnull(abl_sch_fid,0) abl_sch_fid, + s1.name zul_sch, + s2.name abl_sch + FROM haltung + join schacht s1 on s1.fid = haltung.zul_sch_fid + join schacht s2 on s2.fid = haltung.abl_sch_fid + WHERE haltung.ibpprj = '{}'""".format(ibpprj) + res = gpkg_con.executeSql(query) + + + translate_fid = {} + + for row in res: + if row[0] is not NULL and row[1] is not NULL: + graph.add_edge(row[0], row[1]) + translate_fid[row[2]] = row[0] + translate_fid[row[3]] = row[1] + # ZEICHNE SCHNITT + + s_doc = ezdxf.readfile("C:/tmp/schnitte_temp.dxf") # Vorlagendatei + s_msp = s_doc.modelspace() + + pos = {} + + for schn in schnitte: + [source_nam, target_nam, basis] = schn + source = translate_fid[source_nam] + target = translate_fid[target_nam] + + [bx,by] = basis + + if bx == 0: + pos[by] = 0 + elif bx < 10: + bx = pos[by] + + print("Von: ",source_nam," Nach: ",target_nam,) + path = nx.shortest_path(graph, source=source, target=target) + print(path) + ########################################### + # Lade Leitungen und Querungen für den aktuellen Schnitt + ########################################### + + ltg = [] + quer = [] + for i in range(len(path)-1): + query = """SELECT + ifnull(c_laenge,0) c_laenge, + ifnull(zul_sh,0) zul_sh, + ifnull(abl_sh,0) abl_sh, + mat, + ifnull(di,0) di, + ifnull(gefaelle,0) gefaelle, + art + FROM haltung WHERE zul_sch_fid='{}' and abl_sch_fid='{}'""".format(path[i],path[i+1]) + res = gpkg_con.executeSql(query) + + ltg.append({'dist': res[0][0], + 'sh_a': res[0][1], + 'sh_e': res[0][2], + 'mat_dim': res[0][3], + 'di': res[0][4], + 'gef': res[0][5], + 'art': res[0][6], + 'zu': path[i], + 'ab': path[i+1]}) + + query = "SELECT d1, di, h2, art FROM haltung_sp WHERE zul_sch_fid='{}' and abl_sch_fid='{}'".format(path[i],path[i+1]) + res = gpkg_con.executeSql(query) + + for j in res: + print(j) + quer.append({'dist': float(j[0]), + 'dn': j[1], + 'sh': float(j[2]), + 'art': j[3], + 'zu1': path[i], + 'ab1': path[i+1]}) + ########################################### + # Lade Punkte für den aktellen Schnitt + ########################################### + #ws = wb.sheets['Punkte'] + pkt = [] + for i in range(len(path)): + + query = "SELECT name, dh, sh, symbol, schacht_dn, art FROM schacht WHERE fid='{}'".format(path[i]) + res = gpkg_con.executeSql(query) + res[0] = [0 if x == NULL else x for x in res[0]] + pkt.append({'name': res[0][0], + 'dh': res[0][1], + 'sh': res[0][2], + 'symb': res[0][3], + 'dn': res[0][4], + 'art': res[0][5], + 'fid': path[i]}) + + ########################################### + # Lade die Fallrohre für den aktuellen Schnitt + ########################################### + + fr_dat = [] + fr_dat = pd.DataFrame() + # Wähle die Fallrohre, die für den aktuellen Schnitt notwendig sind aus + for i in range(len(path)): + query = "SELECT swf.schacht_fid, swf.kurz, swf.geschoss FROM sw_fallrohre swf WHERE swf.schacht_fid='{}'".format(path[i]) + res = gpkg_con.executeSql(query) + + for i in res: + print(i) + # ALTE VERSION + #fr_dat = fr_dat.append({'schacht_fid': i[0], + # 'objekt': i[1], + # 'geschoss': i[2] + # }, ignore_index=True) + new_row = [{'schacht_fid': i[0], 'objekt': i[1], 'geschoss': i[2]}] + fr_dat = pd.concat([fr_dat, pd.DataFrame(new_row)], ignore_index=True) + + + if len(fr_dat) > 0: + # y-Verschiebung nach oben pro Geschoss (benötigt) - Werte 1 bis Anzahl der Geschosse + df3 = pd.DataFrame() + + query = "SELECT swf.geschoss FROM sw_fallrohre swf JOIN schacht s ON swf.schacht_fid = s.fid WHERE s.ibpprj='{}'".format(ibpprj) + res = gpkg_con.executeSql(query) + + for i in res: + # ALTE VERSION + # df3 = df3.append({'geschoss': i[0]}, ignore_index=True) + + new_row = [{'geschoss': i[0]}] + df3 = pd.concat([df3, pd.DataFrame(new_row)], ignore_index=True) + + #for r in range(8,200): + # df3 = df3.append({'geschoss': ws.range((r,6)).value}, ignore_index=True) + + + # x-Verschiebung nach rechts (nicht benötigt, da durch Fallrohrposition vorgegeben) + fr_dat['x'] = 0 + + df3 = df3[['geschoss']].drop_duplicates().dropna() + df3['y'] = df3['geschoss'].astype(str).str[:2].astype(int)-10 + fr_dat = fr_dat.merge(df3, on='geschoss', how='left') + # Symbole je Fallrohr ordnen + conditions = [(fr_dat['objekt'] == 'BW'),(fr_dat['objekt'] == 'DU'), + (fr_dat['objekt'] == 'WB'),(fr_dat['objekt'] == 'WC'), + (fr_dat['objekt'] == 'GM'),(fr_dat['objekt'] == 'SP'),(fr_dat['objekt'] == 'WM')] + choices = list(range(7,0,-1)) + fr_dat['order'] = np.select(conditions, choices, default=0) + # Symbol-Nummer und maximale Symbolanzahl je Zeile ermitteln + fr_dat['elem_nr'] = fr_dat.sort_values("order").groupby(['geschoss','schacht_fid']).cumcount()+1 + fr_dat['elem_nr_max'] = fr_dat.groupby(['geschoss','schacht_fid'])['geschoss'].transform('size') + # Breite je Symbol zuweisen + choices = [11,5,4,4,4,4,4] #alte Breiten + choices = [i/4 for i in choices] + fr_dat['width'] = np.select(conditions, choices, default=0) + + # Breiten aufsummieren + fr_dat['width_csum'] = fr_dat.sort_values("order").groupby(['geschoss','schacht_fid'])['width'].cumsum()-fr_dat['width'] + + fr_dat['x1'] = fr_dat.x-fr_dat.width_csum + fr_dat['y1'] = 5*mx + fr_dat.y*20*mx + #5 = Basisabstand von FOK // 20 = Geschosshöhe jeweils in mm + fr_dat['symbol'] = "IBP_EW_"+fr_dat['objekt']+"_SCHN" + + ########################################### + # zeichne den Schnitt + ########################################### + # Angaben in Millimeter + band = {} + band['hoehe'] = 8*mx + band['titel_breite'] = 70*mx + # Einheit = Millimeter * mx + # my nur für Höhenanpassung oberhalb des Horizontes notwendig!! + titelfelder = ['Station', 'Geländehöhe', 'Schachtsohle', 'Leitungsohle', 'Deckelhöhe', 'Länge', 'Gefälle', 'Material / DN', 'Punkt'] + titelfelder_einhei = ['m', 'mNN','mNN','mNN','mNN','m','%.','',''] + + x_hor = bx+band['titel_breite'] # Starpunkt Zeichnung + y_hor = by+len(titelfelder)*band['hoehe'] #OK Bänder + + ########################################### + # Titelfelder Bänder + ########################################### + titelfelder_line_dxfatt = {'layer': "##IBP_Schnitt_Fett"} + titelfelder_text_dxfatt = {'style': 'IBP_Norm', 'height': 5.0*mx, 'layer': "##IBP_Schnitt_Text_50", 'width': 0.7} + + s_msp.add_line((bx,by), (bx+band['titel_breite'], by+0), dxfattribs=titelfelder_line_dxfatt) + + for i, v in enumerate(titelfelder, 1): + s_msp.add_line((bx+0, by+i*band['hoehe']), (bx+band['titel_breite'], by+i*band['hoehe']), dxfattribs=titelfelder_line_dxfatt) + y_txt = (i)*band['hoehe']-band['hoehe']/2 + s_msp.add_text(v+":", dxfattribs=titelfelder_text_dxfatt).set_pos((bx+5*mx, by+y_txt), align='MIDDLE_LEFT') + if titelfelder_einhei[i-1] != '': + s_msp.add_text("["+titelfelder_einhei[i-1]+"]", dxfattribs=titelfelder_text_dxfatt).set_pos((bx+band['titel_breite']-15*mx, by+y_txt), align='MIDDLE_RIGHT') + + s_msp.add_line((bx, by), (bx, by+i*band['hoehe']), dxfattribs=titelfelder_line_dxfatt) + s_msp.add_line((bx+band['titel_breite']-10*mx, by), (bx+band['titel_breite']-10*mx, by+i*band['hoehe']), dxfattribs=titelfelder_line_dxfatt) + s_msp.add_text("Horizont: {:.2f}mNN".format(hor), dxfattribs=titelfelder_text_dxfatt + ).set_pos((bx+band['titel_breite']-10*mx, y_hor), align='BOTTOM_RIGHT') + + ########################################### + # Inhalte Bänder + ########################################### + + # Bänder anlegen: + laeng = 0 + laen = [0] + band_beschr_dxfattrib = {'style': 'IBP_Norm', 'height': 2.5*mx, 'layer': "##IBP_Schnitt_Text_25", 'width': 0.7} + band_beschr90_dxfattrib = {'style': 'IBP_Norm', 'height': 2.0*mx, 'layer': "##IBP_Schnitt_Text_20", 'width': 0.7, 'rotation': 90} + band_schnr_dxfattrib = {'style': 'IBP_Norm', 'height': 3.5*mx, 'layer': "##IBP_Schnitt_Text_35", 'width': 0.7} + band_linie_fein_dxfattrib = {'layer': "##IBP_Schnitt_Fein"} + band_linie_fett_dxfattrib = {'layer': "##IBP_Schnitt_Fett"} + # Leitungsdaten: + # Vertikale Linie an der Basis + s_msp.add_line((x_hor,by),(x_hor,y_hor), dxfattribs=band_linie_fein_dxfattrib) + for i in ltg: + xp = x_hor+laeng+i['dist']/2 + # Schreibe Länge in Band + zl = 6 # Zeilennummer + s_msp.add_text("{:.2f}".format(i['dist']), dxfattribs=band_beschr_dxfattrib).set_pos((xp, by+(zl-.5)*band['hoehe']), align='MIDDLE_CENTER') + # Schreibe Gef in Band + zl = 7 # Zeilennummer + s_msp.add_text("{:.2f}".format(i['gef']), dxfattribs=band_beschr_dxfattrib).set_pos((xp, by+(zl-.5)*band['hoehe']), align='MIDDLE_CENTER') + # Schreibe Material / Dim in Band + zl = 8 # Zeilennummer + s_msp.add_text(i['mat_dim'], dxfattribs=band_beschr_dxfattrib).set_pos((xp, by+(zl-.5)*band['hoehe']), align='MIDDLE_CENTER') + laeng = laeng + i['dist'] + laen.append(laeng) + s_msp.add_line((x_hor+laeng,by),(x_hor+laeng,y_hor), dxfattribs=band_linie_fein_dxfattrib) + # Schreibe Sohlhöhen in Band + zl = 4 # Zeilennummer + s_msp.add_text("{:.2f}".format(i['sh_a']), dxfattribs=band_beschr90_dxfattrib).set_pos((x_hor+laeng-i['dist']+1*mx, by+(zl-0.9)*band['hoehe']), align='TOP_LEFT') + s_msp.add_text("{:.2f}".format(i['sh_e']), dxfattribs=band_beschr90_dxfattrib).set_pos((x_hor+laeng-1*mx, by+(zl-0.9)*band['hoehe']), align='BOTTOM_LEFT') + # Horizontale Einfassungen der Bänder + s_msp.add_line((x_hor, by), (x_hor+laeng+20*mx, by), dxfattribs=band_linie_fett_dxfattrib) + for i, v in enumerate(titelfelder, 1): + s_msp.add_line((x_hor, by+i*band['hoehe']), (x_hor+laeng+20*mx, by+i*band['hoehe']), dxfattribs=band_linie_fett_dxfattrib) + # Vertikale Einfassung der Bänder hinten + s_msp.add_line((x_hor+laeng+20*mx, by), (x_hor+laeng+20*mx, by+i*band['hoehe']), dxfattribs=band_linie_fett_dxfattrib) + # Punktdaten + for i, j in enumerate(pkt): + # Schreibe Name in Band + zl = 9 # Zeilennummer + s_msp.add_text(j['name'], dxfattribs=band_schnr_dxfattrib + ).set_pos((x_hor+laen[i]+1*mx, by+(zl-.5)*band['hoehe']), align='MIDDLE_LEFT') + # Schreibe DH in Band + zl = 5 # Zeilennummer + s_msp.add_text("{:.2f}".format(j['dh']), dxfattribs=band_beschr90_dxfattrib + ).set_pos((x_hor+laen[i]+1*mx, by+(zl-.9)*band['hoehe']), align='TOP_LEFT') + # Schreibe SH in Band + zl = 3 # Zeilennummer + s_msp.add_text("{:.2f}".format(j['sh']), dxfattribs=band_beschr90_dxfattrib + ).set_pos((x_hor+laen[i]+1*mx, by+(zl-.9)*band['hoehe']), align='TOP_LEFT') + # Schreibe Station in Band + zl = 1 # Zeilennummer + s_msp.add_text("{:.2f}".format(laen[i]), dxfattribs=band_beschr90_dxfattrib + ).set_pos((x_hor+laen[i]+1*mx, by+(zl-.9)*band['hoehe']), align='TOP_LEFT') + + pos[by] = x_hor+laeng+20*mx+20*mx + + ########################################### + # Zeichne Schnitt-Grafik + ########################################### + ueho = mx/my # Überhöhungsfaktor + + graf_linie_ltg = {} + graf_linie_ltg['SW'] = {'layer': "##IBP_Schnitt_Leitung_SW"} + graf_linie_ltg['RW'] = {'layer': "##IBP_Schnitt_Leitung_RW"} + graf_linie_ltg['MW'] = {'layer': "##IBP_Schnitt_Leitung_MW"} + graf_linie_ltg['Bestand SW'] = {'layer': "##IBP_Schnitt_Leitung_Best_SW"} + graf_linie_ltg['Bestand RW'] = {'layer': "##IBP_Schnitt_Leitung_Best_RW"} + graf_linie_ltg['Bestand MW'] = {'layer': "##IBP_Schnitt_Leitung_Best_MW"} + graf_linie_schacht = {'layer': "##IBP_Schnitt_Schacht"} + graf_linie_geb = {'layer': "##IBP_Schnitt_Gebaeude"} + graf_symb_ew = {'xscale': 1, 'yscale': 1, 'rotation': 0, 'layer': 'KANAL-SW_Planung_Schnitt_Sym'} + # zeichne Leitungen + for i,j in enumerate(ltg): + s_msp.add_line( (x_hor+laen[i], y_hor+(j['sh_a']-hor)*ueho), + (x_hor+laen[i+1], y_hor+(j['sh_e']-hor)*ueho), + dxfattribs=graf_linie_ltg[j['art']]) + s_msp.add_line(( x_hor+laen[i], y_hor+(j['sh_a']-hor+j['di']/1000)*ueho), (x_hor+laen[i+1],y_hor+(j['sh_e']-hor+j['di']/1000)*ueho), + dxfattribs=graf_linie_ltg[j['art']]) + print(quer) + for k in quer: + if j['zu'] == k['zu1'] and j['ab'] == k['ab1']: + s_msp.add_circle((x_hor+laen[i]+k['dist'], y_hor+(k['sh']-hor+k['dn']/2/1000)*ueho), #@ToDo bei Überhöhung eigentlich Ellipse!!!! + k['dn']/2/1000, dxfattribs=graf_linie_ltg[k['art']]) + #s_msp.add_ellipse + # Zeichne Punkte + for i,j in enumerate(pkt): + x_a = x_hor+laen[i] #Aktuelle X-Position + #vertikale Linie + s_msp.add_line((x_a, y_hor),(x_a,y_hor+(max(j['dh'],j['sh'])-hor)*ueho), + dxfattribs=band_linie_fein_dxfattrib) + sh_e = ltg[i-1]['sh_a'] if i > 0 else j['sh'] + dh = j['dh'] if j['dh'] > 0 else j['sh'] + s_msp.add_line((x_a-j['dn']/2/1000, y_hor+(min(dh,j['sh'])-hor)*ueho), + (x_a-j['dn']/2/1000, y_hor+((max(dh,j['sh'],sh_e)-hor)*ueho)), + dxfattribs=graf_linie_schacht) + s_msp.add_line((x_a+j['dn']/2/1000, y_hor+(min(dh,j['sh'])-hor)*ueho), + (x_a+j['dn']/2/1000, y_hor+(max(dh,j['sh'],sh_e)-hor)*ueho), + dxfattribs=graf_linie_schacht) + s_msp.add_line((x_a-j['dn']/2/1000, y_hor+(min(dh,j['sh'])-hor)*ueho), + (x_a+j['dn']/2/1000, y_hor+(min(dh,j['sh'])-hor)*ueho), + dxfattribs=graf_linie_schacht) + s_msp.add_line((x_a-j['dn']/2/1000, y_hor+(max(dh,j['sh'],sh_e)-hor)*ueho), + (x_a+j['dn']/2/1000, y_hor+(max(dh,j['sh'],sh_e)-hor)*ueho), + dxfattribs=graf_linie_schacht) + # Wenn Fallrohr dann EW-Gegenstände zeichnen + if j['symb'] == "Fallrohr": + abst = 2.5*mx*ueho #45° gewinkelte Linie + #Zeichne Fallrohre: + xp = x_a-j['dn']/2/1000 + yp = y_hor+(j['sh']-hor)*ueho + + points = [(xp,yp),(xp-abst,yp+abst),(xp-abst,yp+50*mx*ueho)] + s_msp.add_lwpolyline(points, dxfattribs=graf_linie_ltg[j["art"]]) + xp = x_a+j['dn']/2/1000 + points = [(xp,yp),(xp-abst,yp+abst),(xp-abst,yp+50*mx*ueho)] + s_msp.add_lwpolyline(points, dxfattribs=graf_linie_ltg[j["art"]]) + #Zeichne Gegenstände mit Leitung + for index, row in fr_dat.iterrows(): + xp = x_a + row['x1'] - abst - 8*mx #8*mx = Abstand von der Fallleitung + yp = y_hor + (fok-hor + row['y1'])*ueho + + if row['schacht_fid'] == j['fid']: + s_msp.add_blockref(row['symbol'], [xp,yp], dxfattribs=graf_symb_ew) + #Leitung horizontal und Geschosslinie + if(row['elem_nr'] == row['elem_nr_max']): + # Leitung + x2 = x_a + row['x'] - 2*abst # Abzgl. 2x 45° Schräge + points = [(xp,yp), (x2,yp), (x2+abst,yp-abst)] + s_msp.add_lwpolyline(points, dxfattribs=graf_linie_ltg["SW"]) + # Gebäudelinie + yp = y_hor + ((fok-hor)*10*my + 20*row['y']*mx)*ueho + s_msp.add_line((xp-5*abst,yp),(x2+5*abst,yp), dxfattribs=graf_linie_geb) + + ########################################### + # Layout-Rahmen + ########################################### + + s_msp.add_line( (bx-10*mx ,by-10*mx), (pos[by]-10*mx ,by-10*mx), + dxfattribs={'layer': "##IBP_nicht_drucken"}) + + s_doc.saveas(schnitte_filename) + + ibp_dxf_to_dwg(schnitte_filename.split("/")[-1],schnitte_filename.replace(schnitte_filename.split("/")[-1],"")) + #ibp_dxf_to_dwg(schnitte_filename.split("/")[-1]) + + + +def reduce_list(input_list: list) -> list: + """ + Entfernung der Teilstücke welche in den vorangegangenen Pfaden schon beeinhaltet sind + :param input_list: Liste mit Listen welche alle Pfade beinhaltet + :return: Reduzierte Liste, Teilstücke wurden entfernt + """ + output_list = [] + seen_values = set() + for group in sorted(input_list,key=len)[::-1]: + if not set(group).issubset(seen_values): + output_list.append(group) + seen_values.update(group) + return output_list + +def ibp_calc_netz(): + #-- Bestimme Schachtanschlüsse und Länge + gpkg_con.executeSql("""UPDATE haltung SET + zul_sch_fid = (SELECT fid FROM schacht s WHERE distance(geomfromgpb(s.geom), startpoint(geomfromgpb(haltung.geom))) < 0.1 LIMIT 1), + abl_sch_fid = (SELECT fid FROM schacht s WHERE distance(geomfromgpb(s.geom), endpoint(geomfromgpb(haltung.geom))) < 0.1 LIMIT 1);""") + + #-- Reset zu Beginn + gpkg_con.executeSql("UPDATE schacht SET sh = 0;") + gpkg_con.executeSql("UPDATE haltung SET zul_sh = 0, abl_sh = 0, c_laenge = ST_Length(geomfromgpb(geom)), gefaelle = gefaelle_vorg;") + + #-- Setze fixierte Sohlhöhen + gpkg_con.executeSql("UPDATE schacht SET sh = sh_fix WHERE sh_fix > 0;") + + #-- Setze fixierte Schachthöhen auf Haltungen + gpkg_con.executeSql("""UPDATE haltung SET + zul_sh = (SELECT sh_fix FROM schacht WHERE schacht.fid = haltung.zul_sch_fid) + WHERE haltung.zul_sch_fid IN (SELECT schacht.fid FROM schacht WHERE schacht.sh_fix > 0);""") + gpkg_con.executeSql("""UPDATE haltung SET + abl_sh = (SELECT sh_fix FROM schacht WHERE schacht.fid = haltung.abl_sch_fid) + WHERE haltung.abl_sch_fid in (SELECT schacht.fid FROM schacht WHERE schacht.sh_fix > 0);""") + + gpkg_con.executeSql("UPDATE haltung SET zul_sh = zul_sh_fix WHERE zul_sh_fix > 0;") + gpkg_con.executeSql("UPDATE haltung SET abl_sh = abl_sh_fix WHERE abl_sh_fix > 0;") + + graph = nx.DiGraph() + + cols = ["zul_sch_fid", "abl_sch_fid"] + query = "SELECT "+",".join(cols)+" FROM haltung" + + res = gpkg_con.executeSql(query) + dat = [dict(zip(cols, row)) for row in res] + #print(dat) + for row in dat: + graph.add_edge(row["zul_sch_fid"], row["abl_sch_fid"]) + + cols = ["schacht_bezug", "zul_sch_fid", "abl_sch_fid"] + query = "SELECT "+",".join(cols)+" FROM haltung WHERE (schacht_bezug > 0) and (zul_sh = 0 or abl_sh = 0 or zul_sh is null or abl_sh is null) ORDER BY schacht_bezug" + + res = gpkg_con.executeSql(query) + dat = [dict(zip(cols, row)) for row in res] + #print(dat) + """ + Nachfolgender Code ist ggf. in eine Schleife zu packen, + Wenn eine Abhängigkeit sich erst löst wenn andere Berechnungen fertig gestellt sind. + + Ggf. muss auch die initial-Abfrage noch leicht modifiziert werden + """ + paths = [] + for i in dat: + source_fid = i['schacht_bezug'] + target_fid = i['zul_sch_fid'] + #print(source_fid, target_fid) + try: + path = nx.shortest_path(graph, source=source_fid, target=target_fid) + path.append(i['abl_sch_fid']) + path.insert(0,1) + #print("oben", path, source_fid, target_fid) + paths.append(path) + except nx.NetworkXNoPath: + try: + path = nx.shortest_path(graph, source=target_fid, target=source_fid) + path = path[::-1] + path.insert(0,-1) + #print("unten", path, source_fid, target_fid) + paths.append(path) + except nx.NetworkXNoPath: + print("no path", source_fid, target_fid) + except: + print("error", source_fid, target_fid, i) + break + + cnt = 0 + cnt_query = "SELECT COUNT(*) FROM haltung WHERE abl_sh = 0 or zul_sh = 0" + + while cnt != gpkg_con.executeSql(cnt_query)[0][0]: + cnt = gpkg_con.executeSql(cnt_query)[0][0] + + for path in paths: + direction = path[0] + path = path[1:] + + ## von Oben nach unten: + if direction == 1: + for i in range(len(path)-1): + query = """UPDATE haltung SET + abl_sh = zul_sh-gefaelle/1000*c_laenge + WHERE zul_sch_fid={0} and abl_sch_fid={1} and zul_sh > 0;""".format(path[i],path[i+1]) + res = gpkg_con.executeSql(query) + + if i < len(path)-2: ## ggf. anpassen + query = """UPDATE haltung SET + zul_sh = (SELECT abl_sh FROM haltung WHERE zul_sch_fid={0} and abl_sch_fid={1} and abl_sh > 0) + WHERE zul_sch_fid ={1} and abl_sch_fid = {2};""".format(path[i],path[i+1],path[i+2]) + #print(query) + res = gpkg_con.executeSql(query) + ## von unten nach oben: + elif direction == -1: + for i in range(len(path)-1): + query = """UPDATE haltung SET + zul_sh = abl_sh+gefaelle/1000*c_laenge + WHERE abl_sch_fid={0} and zul_sch_fid={1} and abl_sh > 0;""".format(path[i],path[i+1]) + res = gpkg_con.executeSql(query) + #if path[i] == 198 and path[i+1] == 184: + # print(query) + + if i < len(path)-2: ## ggf. anpassen + query = """UPDATE haltung SET + abl_sh = (SELECT zul_sh FROM haltung WHERE abl_sch_fid={0} and zul_sch_fid={1} and zul_sh > 0) + WHERE abl_sch_fid ={1} and zul_sch_fid = {2};""".format(path[i],path[i+1],path[i+2]) + res = gpkg_con.executeSql(query) + + gpkg_con.executeSql("""UPDATE haltung SET + zul_sh = (SELECT sh+stichmas FROM schacht WHERE schacht.fid = haltung.zul_sch_fid) + WHERE + haltung.zul_sh = 0 or haltung.zul_sh IS NULL;""") + gpkg_con.executeSql("""UPDATE haltung SET + abl_sh = (SELECT sh+stichmas FROM schacht WHERE schacht.fid = haltung.abl_sch_fid) + WHERE + haltung.abl_sh = 0 or haltung.abl_sh IS NULL;""") + + gpkg_con.executeSql("""UPDATE schacht SET + sh = IIF(sh_fix > 0, sh_fix, (SELECT min(ber_sh) FROM + ( + SELECT abl_sh ber_sh FROM haltung WHERE abl_sch_fid = schacht.fid and abl_sh > 0 + UNION + SELECT zul_sh ber_sh FROM haltung WHERE zul_sch_fid = schacht.fid and zul_sh > 0 + ) WHERE ber_sh > 0)-stichmas);""") + gpkg_con.executeSql("""UPDATE haltung SET + gefaelle = (zul_sh - abl_sh)/c_laenge*1000 WHERE zul_sh > 0 and abl_sh > 0""") + + + gpkg_con.executeSql("""UPDATE haltung SET + gefaelle = NULL WHERE zul_sh = 0 or abl_sh = 0 or zul_sh is null or abl_sh is null""") + + +################################################################################################################################################ +################################################################################################################################################ + +# Berechnet die Hydraulik der Leitungen +# Ausgangsdaten-Tabelle: haltung +# Ergebnis-Tablle: haltung_calc_hydraulik +def ibp_hydraulik(ibpprj = ""): + con = sqlite3.connect(inp_file) + + query = "PRAGMA table_info(haltung)" + col = gpkg_con.executeSql(query) + + coln = [] + for i in col: + coln.append(i[1]) + coln = ['fid','di','gefaelle','Qtot','ibpprj'] + + query = 'SELECT '+",".join(coln)+' FROM haltung WHERE 0<'+" and 0 < ".join(coln)+' ' + #query = 'SELECT '+",".join(coln)+' FROM haltung WHERE ibpprj = "{0}"'.format(ibpprj) + res = gpkg_con.executeSql(query) + + df = pd.DataFrame(res, columns = coln) + + df['Av']=(df['di']/1000)**2/4*np.pi + nu = 0.00000131 + g = 9.81 + kb = 0.50 + + df = df.dropna() + + df['vv'] = -2*np.log10(2.51*nu/(4*df['di']/4000*np.sqrt(8*g*df['di']/4000*df['gefaelle']/1000))+kb/(1000*(14.84*df['di']/4000)))*np.sqrt(8*g*df['di']/4000*df['gefaelle']/1000) + + df['Qv'] = df['Av']*df['vv']*1000 + + df['ausl'] = df['Qtot']/df['Qv'] + + def ber_ht(df,ht): + di_m = df['di']/1000 + r_m = di_m/2 + nu = 0.00000131 + g = 9.81 + kb = 0.50 + + #Kreissegment: + # Quelle Wikipedia: https://de.wikipedia.org/wiki/Kreissegment + # At = r_m**2*np.arccos(1-ht/r_m)-(r_m-ht)*np.sqrt(2*r_m*ht-ht**2) + At = (df['di']/1000)**2/8*((4*np.arcsin(np.emath.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.emath.sqrt(ht/(df['di']/1000)))))) + + #Iu = 0.5*di_m*(4*np.arcsin(np.sqrt(ht/di_m))) + Iu = 0.5*df['di']/1000*(4*np.arcsin(np.emath.sqrt(ht/(df['di']/1000)))) + #Iu = Iu.fillna(0) + + rhy = At/Iu + + #vt = -2*np.log10(2.51*nu/(4*rhy*np.sqrt(8*g*rhy*df['gefaelle']/1000))+kb/(1000*14.84*rhy))*np.sqrt(8*g*rhy*df['gefaelle']/1000) + vt = -2*np.log10(2.51*nu/(4*rhy*np.emath.sqrt(8*g*rhy*df['gefaelle']/1000))+kb/(1000*(14.84*rhy)))*np.emath.sqrt(8*g*rhy*df['gefaelle']/1000) + #vt = vt.fillna(0) + + Qt=At*vt*1000 + + return Qt + + df['ht'] = np.ones(len(df['ausl'])) + + #func = lambda ht : df['Qtot'] - (((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))*(-2*np.log10(2.51*nu/(4*(((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))/(0.5*df['di']/1000*(4*np.arcsin(np.sqrt(ht/(df['di']/1000))))))*np.sqrt(8*g*(((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))/(0.5*df['di']/1000*(4*np.arcsin(np.sqrt(ht/(df['di']/1000))))))*df['gefaelle']/1000))+kb/(1000*(14.84*(((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))/(0.5*df['di']/1000*(4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))))*np.sqrt(8*g*(((df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(ht/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(ht/(df['di']/1000)))))))/(0.5*df['di']/1000*(4*np.arcsin(np.sqrt(ht/(df['di']/1000))))))*df['gefaelle']/1000))*1000) + + for index, row in df.iterrows(): + + if row['Qtot'] < 0.01: + df['ht'][index] = 0 + else: + func = lambda ht : row['Qtot'] - ber_ht(row,ht) + erg = scipy.optimize.fsolve(func, 0.001, full_output=True) + if erg[2] > 1: + erg = scipy.optimize.fsolve(func, 0.01, full_output=True) + if erg[2] > 1: + print(index, " ", row['fid'], " ", erg) + + df['ht'][index] = erg[0] + + #df['ht'] = scipy.optimize.fsolve(func, np.ones(len(df['ausl']))*0.1) + + df['h/d'] = df['ht']/df['di']*1000 + df['At'] = (df['di']/1000)**2/8*((4*np.arcsin(np.sqrt(df['ht']/(df['di']/1000))))-np.sin((4*np.arcsin(np.sqrt(df['ht']/(df['di']/1000)))))) + df['Iu'] = 0.5*df['di']/1000*(4*np.arcsin(np.sqrt(df['ht']/(df['di']/1000)))) + df['rhy'] = df['At']/df['Iu'] + df['vt'] = -2*np.log10(2.51*nu/(4*df['rhy']*np.sqrt(8*g*df['rhy']*df['gefaelle']/1000))+kb/(1000*(14.84*df['rhy'])))*np.sqrt(8*g*df['rhy']*df['gefaelle']/1000) + + df['Qt'] = df['At']*df['vt']*1000 + + + df['tau'] = 1000*g*df['rhy']*df['gefaelle']/1000 + + df.to_sql('haltung_calc_hydraulik',con,if_exists='replace') + + + + + + diff --git a/upload/icon_txt.png b/upload/icon_txt.png new file mode 100644 index 0000000000000000000000000000000000000000..8f3321464a8abd1010120e3ce831a0b840d439cf GIT binary patch literal 1281 zcmV+c1^)VpP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D1eQreK~#8N?c6&^ zD@zy$@MAzw1Z@-q112^SMX}Z9ifCtLe1M%r3ce^&%ItizoBcbplkAGWGVBWn0UQKy5WqozE{M<1 zPyCeC*Vp%}fHgNaKRi6(z4~J_A__bR5>yt-2SEbK!X}7#JdUFkww9Kb`}=#mX-|q_ zL&Axw(l0 zYiw<8B@zj|Frhheb900Kj;R_1HRZ^np`pQT7KI+f#>NH?tU>9B*0HfMY%+11h1x-o zpt4Xt2r@A-fd&)G;_B)ObvYG75F|$y_4V~mvakula`{BtkFX3vTr3SHCnwQt5{*Vt zBv&LOLYSYQM}-M0+I~r8`Z$>g7k1Xx){c&j z@IvGC^c2T%3_UZM!NEbCy$0Ik{;Tlth1YO5`ThNUWMqW4MuA+E$Xrc1_s{V-b8_7L5N3hFE20E)z#RfH#IdScCPjG^wieYh6=qz zA|Yxh6l`)#bR?F2(I)3Bi0=`xy}gZ1ChP0#qDJ`m_~_~BL7N_p5gI9?Ox3ADW@l%y zRj;(Pbbo&zMVZX#=qMWW=z2j{4HV@!2*dI@Jw1(mXc(Tg8J176WSCV|Rh^xkQNiNk zA~u=q?d^%32!`d;@-`&eve482@@ZiC(9!aFyjFL2H%j%Q(P%1_!V8m?l@;`t7#bQv zsRr6iTor$lR#?sy!v_bm$H&K5EQV@l#>dCeSGLAGSqX>3-;1R!g@Yh-b93lsLW`wX zM;yv$5OmJihlcH{p|!NMgl;Bvb#*5vC#ZA4)ruJK^2t*J_+km3gW%=!k0Sg) rz(D{90UQKy5WqnI2LT+!mrUk2TqMH*CU%<@00000NkvXXu0mjfPvS$4 literal 0 HcmV?d00001 diff --git a/upload/metadata.txt b/upload/metadata.txt new file mode 100644 index 0000000..c899356 --- /dev/null +++ b/upload/metadata.txt @@ -0,0 +1,47 @@ +# This file contains metadata for your plugin. + +# This file should be included when you package your plugin.# Mandatory items: + +[general] +name=IBP Tools +qgisMinimumVersion=3.0 +description=Werkzeugsammlung des Ingenieurbüro Pertl +version=0.1 +author=Sebastian Pertl +email=sebastian@pertl-ing.de + +about= + +tracker=http://bugs +repository=http://repo +# End of mandatory metadata + +# Recommended items: + +hasProcessingProvider=no +# Uncomment the following line and add your changelog: +# changelog= + +# Tags are comma separated with spaces allowed +tags=python + +homepage=http://homepage +category=Plugins +icon=icon.png +# experimental flag +experimental=False + +# deprecated flag (applies to the whole plugin, not just a single version) +deprecated=False + +# Since QGIS 3.8, a comma separated list of plugins to be installed +# (or upgraded) can be specified. +# Check the documentation for more information. +# plugin_dependencies= + +Category of the plugin: Raster, Vector, Database or Web +# category= + +# If the plugin can run on QGIS Server. +server=False + diff --git a/upload/plugin_upload.py b/upload/plugin_upload.py new file mode 100644 index 0000000..a88ea2b --- /dev/null +++ b/upload/plugin_upload.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python +# coding=utf-8 +"""This script uploads a plugin package to the plugin repository. + Authors: A. Pasotti, V. Picavet + git sha : $TemplateVCSFormat +""" + +import sys +import getpass +import xmlrpc.client +from optparse import OptionParser + +standard_library.install_aliases() + +# Configuration +PROTOCOL = 'https' +SERVER = 'plugins.qgis.org' +PORT = '443' +ENDPOINT = '/plugins/RPC2/' +VERBOSE = False + + +def main(parameters, arguments): + """Main entry point. + + :param parameters: Command line parameters. + :param arguments: Command line arguments. + """ + address = "{protocol}://{username}:{password}@{server}:{port}{endpoint}".format( + protocol=PROTOCOL, + username=parameters.username, + password=parameters.password, + server=parameters.server, + port=parameters.port, + endpoint=ENDPOINT) + print("Connecting to: %s" % hide_password(address)) + + server = xmlrpc.client.ServerProxy(address, verbose=VERBOSE) + + try: + with open(arguments[0], 'rb') as handle: + plugin_id, version_id = server.plugin.upload( + xmlrpc.client.Binary(handle.read())) + print("Plugin ID: %s" % plugin_id) + print("Version ID: %s" % version_id) + except xmlrpc.client.ProtocolError as err: + print("A protocol error occurred") + print("URL: %s" % hide_password(err.url, 0)) + print("HTTP/HTTPS headers: %s" % err.headers) + print("Error code: %d" % err.errcode) + print("Error message: %s" % err.errmsg) + except xmlrpc.client.Fault as err: + print("A fault occurred") + print("Fault code: %d" % err.faultCode) + print("Fault string: %s" % err.faultString) + + +def hide_password(url, start=6): + """Returns the http url with password part replaced with '*'. + + :param url: URL to upload the plugin to. + :type url: str + + :param start: Position of start of password. + :type start: int + """ + start_position = url.find(':', start) + 1 + end_position = url.find('@') + return "%s%s%s" % ( + url[:start_position], + '*' * (end_position - start_position), + url[end_position:]) + + +if __name__ == "__main__": + parser = OptionParser(usage="%prog [options] plugin.zip") + parser.add_option( + "-w", "--password", dest="password", + help="Password for plugin site", metavar="******") + parser.add_option( + "-u", "--username", dest="username", + help="Username of plugin site", metavar="user") + parser.add_option( + "-p", "--port", dest="port", + help="Server port to connect to", metavar="80") + parser.add_option( + "-s", "--server", dest="server", + help="Specify server name", metavar="plugins.qgis.org") + options, args = parser.parse_args() + if len(args) != 1: + print("Please specify zip file.\n") + parser.print_help() + sys.exit(1) + if not options.server: + options.server = SERVER + if not options.port: + options.port = PORT + if not options.username: + # interactive mode + username = getpass.getuser() + print("Please enter user name [%s] :" % username, end=' ') + + res = input() + if res != "": + options.username = res + else: + options.username = username + if not options.password: + # interactive mode + options.password = getpass.getpass() + main(options, args) diff --git a/upload/qgs_interface.py b/upload/qgs_interface.py new file mode 100644 index 0000000..9536fda --- /dev/null +++ b/upload/qgs_interface.py @@ -0,0 +1,33 @@ +import sys +import requests +import toml +import os + +""" + +Excel-Test: + +=HYPERLINK("qgs://test") + +""" + + +file_path = os.path.dirname(os.path.realpath(__file__)) + +with open(file_path + '\\config.toml', 'r') as f: + config = toml.load(f) + +#print ('argument list', sys.argv) +call = sys.argv[1].replace("qgs://","") + +#print ("Hello {}. How are you?".format(name)) +print("Befehl:") +print("{}".format(call)) +print("") + +requests.get("http://{}:{}/{}".format(config['iface']['host'],config['iface']['port'],call)) + +if config['iface']['debug']: + os.system("pause") + +