datenbank

118 """ 119 Klasse zum Datenbankzugriff auf PostgreSQL-Datenbanken. Es wird die Datenbankverbindung hergestellt und eine Transaktion gestartet. 120 121 @keyword dbBenutzerName: Es ist der Datenbankbenutzername zu übergeben. 122 @type dbBenutzerName: Zeichenkette 123 @keyword dbKennwort: Es ist das Kennwort des Datenbankbenutzers zu übergeben. 124 @type dbKennwort: Zeichenkette 125 @keyword hostaddr: Es ist die IP-Adresse anzugeben, über die der PostgreSQL-Datenbankserver ansprechbar ist. 126 @type hostaddr: Zeichenkette 127 128 @raise Fehler: Fehlermeldung und Programmende, wenn die Datenbankverbindung nicht hergestellt werden kann. 129 """ 130 131 132 133 134 # 135 # ------------------------------------------------------------------------------------ 136 # -- Datenbankverbindung herstellen ---------------------------------- 137 # ------------------------------------------------------------------------------------ 138 #

139 - def __init__( self, dbBenutzerName, dbKennwort, hostaddr ):

140 141 # 142 # -- globale Variablen bereitstellen ---------------------------------- 143 # -- -------------------------- 144 # -- Anzahl der gelesenen Spalten / Zeilen -------------------------- 145 # -- Wurden Werte zurückgegeben ? -------------------------- 146 # -- Cursorobjekt -------------------------- 147 # -- Objekt für die Abfrageergebnisse bereitstellen -------------------------- 148 # 149 self.anzSpalten = 0 150 """ 151 @requires: Erst ist C{__dbAbfrage__(...)} auszuführen.. 152 153 @cvar: Enthält die Anzahl der gelesenen Spalten. 154 @type: Ganzzahl 155 """ 156 157 self.anzZeilen = 0 158 """ 159 @requires: Erst ist C{__dbAbfrage__(...)} auszuführen.. 160 161 @cvar: Enthält die Anzahl der gelesenen Zeilen (Tuples). 162 @type: Ganzzahl 163 """ 164 165 self.hatWerte = False 166 """ 167 @requires: Erst ist C{__dbAbfrage__(...)} auszuführen.. 168 169 @cvar: Die Datenbankabfrage hat Werte zurückgegeben. 170 @type: Boolean 171 """ 172 173 self.dbCursor = None 174 """ 175 @cvar: Datenbankobjekt, welches den systemweit geltenden Datenbankcursor repräsentiert. 176 @type: PgSQL - Cursor Object 177 """ 178 179 self.__dbAbfrage__Ergebnis = None 180 """ 181 @cvar: Repräsentiert das Ergebnis der SQL-Abfrage. 182 @type: PgSQL - Cursor Object 183 """ 184 185 # 186 # -- Datenbankverbindung entsprechend ---------- 187 # -- Python Database API Specification v2.0 (PEP: 249) ---------- 188 # 189 try: 190 self.dbVerbindung = PgSQL.connect( database = "vf" 191 , user = dbBenutzerName 192 , password = dbKennwort 193 , host = hostaddr 194 , client_encoding = ("utf-8",) 195 , unicode_results = 1 196 ) 197 """ 198 @cvar: Datenbankobjekt, welches die Datenbankverbindung enthält. 199 @type: PgSQL - Connection Object 200 """ 201 202 except PgSQL.Error, msg: 203 raise Fehler( "Die Verbindung zum Datenbankserver (PostgreSQL) konnte nicht hergestellt werden.\n\n" + str( msg ) + "\n" + "'wxvf' wird beendet." ) 204 205 206 # 207 # -- Transaktion starten -------------------------- 208 # 209 # self.__dbAbfrage__( 'BEGIN;' ) 210 211 212 # 213 # -- Tabellen, die auf >spr.uebvar.id< referenzieren auslesen ---------- 214 # 215 self.listeTabellenSprUebvarId = self.__liesTabSpFremdschluessel__( zielSpalte = 'spr.uebvar.id' ) 216 """ 217 @cvar: Es werden die Tabellennamen einschliesslich Spaltennamen zusammengefaßt, die aud C{spr.uebvar.id} referenzieren. Die Tabelle C{spr.uebersetzung.spr_uebvar_id} wird nicht aufgeführt ! 218 @type: Python-Liste 219 """ 220 221 222 # 223 # -- >spr.uebersetzung.spr_uebvar_id< entfernen -------------------------- 224 # 225 for i in range( len( self.listeTabellenSprUebvarId ) ) : 226 227 if( self.listeTabellenSprUebvarId[i][0] == 'spr.uebersetzung' ) : 228 229 del self.listeTabellenSprUebvarId[i] 230 break

231 232 233 234 235 236 # 237 # ------------------------------------------------------------------------------------ 238 # -- Datenbankabfrage -------------------------------------------------- 239 # ------------------------------------------------------------------------------------ 240 #

241 - def __dbAbfrage__( self, sql ):

242 """ 243 Methode zur Datenbankabfrage (die mittels C{sql} übergebenen SQL-Abfrage ausführen). 244 245 @param sql: Es ist die SQL-Abfrage zu übergeben. 246 @type sql: Zeichenkette 247 248 @raise Fehler: Fehlermeldung, wenn die SQL-Abfrage nicht erfolgreich war. 249 """ 250 251 # 252 # -- CURSOR bereitstellen -------------------------------------------------- 253 # 254 if( self.dbCursor == None ) : self.dbCursor = self.dbVerbindung.cursor() 255 256 257 # 258 # -- Datenbank abfragen, ------------------------------------------ 259 # -- Datenbankabfrageobjekt anlegen ------------------------------------------ 260 # 261 self.anzSpalten = 0 262 self.anzZeilen = 0 263 try: 264 265 # 266 # -- SQL-Abfrage ausführen ------------------------------------------ 267 # 268 self.dbCursor.execute( sql ) 269 270 271 # 272 # -- für SQL-Abfragen, die keine Zeilen liefern (BEGIN, ...) ---------- 273 # 274 self.hatWerte = not( self.dbCursor.description == None ) 275 if( not self.hatWerte ) : 276 return 277 # -- Notlösung -------------------------------------------------- 278 if( sql.find( "SAVEPOINT" ) > -1 ) : return 279 280 281 282 self.__dbAbfrage__Ergebnis = self.dbCursor.fetchall() 283 284 285 # 286 # -- für SELECT-Abfragen, die keine Zeilen liefern ------------------ 287 # 288 self.hatWerte = not( self.__dbAbfrage__Ergebnis == [] ) 289 if( not self.hatWerte ) : 290 return 291 292 293 except PgSQL.Error, msg: 294 raise Fehler( msg ) 295 296 297 # 298 # -- Zeilenanzahl, Spaltenanzahl übernehmen ---------------------------------- 299 # 300 self.anzSpalten = len( self.dbCursor.description ) 301 self.anzZeilen = self.dbCursor.rowcount

302 303 304 305 # 306 # ------------------------------------------------------------------------------------ 307 # -- Spaltenanzahl zurückgeben ------------------------------------------ 308 # ------------------------------------------------------------------------------------ 309 #

310 - def __gibAnzSpalten__( self ):

311 """ 312 Methode die die Anzahl der gelesenen Spalten der C{__dbAbfrage__( ..., lfdNr )} zurückgibt. 313 314 @requires: Erst ist C{__dbAbfrage__( ..., lfdNr )} auszuführen. 315 316 @return: Es wird die Spaltenanzahl zurückgegeben. 317 @rtype: Ganzzahl 318 """ 319 320 # 321 # -- Spaltenanzahl zurückgeben ------------------------------------------ 322 # 323 return self.anzSpalten

324 325 326 327 328 # 329 # ------------------------------------------------------------------------------------ 330 # -- Zeilenanzahl zurückgeben ------------------------------------------ 331 # ------------------------------------------------------------------------------------ 332 #

333 - def __gibAnzZeilen__( self ):

334 """ 335 Methode die die Anzahl der gelesenen Zeilen der C{__dbAbfrage__( ..., lfdNr )} zurückgibt. 336 337 @requires: Erst ist C{__dbAbfrage__( ..., lfdNr )} auszuführen. 338 339 @return: Es wird die Zeilenanzahl zurückgegeben. 340 @rtype: Ganzzahl 341 """ 342 343 # 344 # -- Zeilenanzahl zurückgeben ------------------------------------------ 345 # 346 return self.anzZeilen

347 348 349 350 # 351 # ------------------------------------------------------------------------------------ 352 # -- Werte zurückgeben -------------------------------------------------- 353 # ------------------------------------------------------------------------------------ 354 #

355 - def __gibWert__( self, zeilenNr, spaltenNr ):

356 """ 357 Methode zur Rückgabe des gelesenen Wertes, der mittels C{zeilenNr, spaltenNr} angegeben wird. 358 Wenn aus der Datenbank C{NULL} gelesen wird, wird eine leere Zeichenkette zurückgegeben. 359 360 @requires: Erst ist C{__dbAbfrage__(...)} auszuführen.. 361 362 @param zeilenNr: Es ist die Zeilennummer zu übergeben. 363 @type zeilenNr: Ganzzahl 364 365 @param spaltenNr: Es ist die Spaltennummer zu übergeben. 366 @type spaltenNr: Ganzzahl 367 368 @return: Es wird der gelesenen Wert zurückgegeben. 369 @rtype: Datentyp des jeweiligen Wertes 370 """ 371 372 # 373 # -- keine Werte vorhanden -------------------------------------------------- 374 # 375 if( not self.__hatWerte__() 376 or zeilenNr > self.__gibAnzZeilen__() 377 or spaltenNr > self.__gibAnzSpalten__() ) : 378 return "" 379 380 381 # 382 # -- NULL vorhanden ---------------------------------------------------------- 383 # 384 if( len( self.__dbAbfrage__Ergebnis ) == 0 ) : 385 return "" 386 387 if( self.__dbAbfrage__Ergebnis[zeilenNr][spaltenNr] == None ) : 388 return "" 389 390 391 # 392 # -- Werte zurückgeben -------------------------------------------------- 393 # 394 if( self.dbCursor.description[spaltenNr][1] == PgSQL.STRING ) : 395 return self.__dbAbfrage__Ergebnis[zeilenNr][spaltenNr].encode('utf-8') 396 else : 397 return self.__dbAbfrage__Ergebnis[zeilenNr][spaltenNr]

398 399 400 401 402 # 403 # ------------------------------------------------------------------------------------ 404 # -- Die SQL-Abfrage hat Werte zurückgegeben -------------------------- 405 # ------------------------------------------------------------------------------------ 406 #

407 - def __hatWerte__( self ):

408 """ 409 Die C{__dbAbfrage__( ..., lfdNr )} hat Werte zurückgegeben. 410 411 @requires: Erst ist C{__dbAbfrage__( ..., lfdNr )} auszuführen. 412 413 @return: Es wird C{True} zurückgegeben, wenn die C{__dbAbfrage__( ..., lfdNr )} Werte zurückgegeben hat. 414 @rtype: Boolean 415 """ 416 417 # 418 # -- Zeilenanzahl zurückgeben ------------------------------------------ 419 # 420 return self.hatWerte

421 422 423 424 # 425 # ------------------------------------------------------------------------------------ 426 # -- wxControlWithItems initialisieren ---------------------------------- 427 # ------------------------------------------------------------------------------------ 428 #

429 - def __initWxControlWithItems__( self, sql, eintragNull, wxObj ):

430 """ 431 Interne Methode zur Initialisierung eines C{wx-Objektes}, welches eine Listenform hat. 432 433 @note: Das übergebene C{wx-Objekt} wird verändert ! 434 435 @param sql: Es ist die SQL-Abfrage zu übergeben, die die Einträge der Liste erzeugt. In der ersten Spalte der SQL-Abfrage muß der Wert stehen, der im wxObj dargestellt wird. In den nächsten Spalten können zusätzliche (nicht sichtbare) Werte übergeben werden. 436 @type sql: Zeichenkette 437 @param eintragNull: Es ist der erste in der Liste darzustellende Eintrag anzugeben. In Form einer Liste mit zwei Einträgen wird im ersten Eintrag der Text und im zweiten Eintrag als weitere Liste (auch wenn nur ein Wert übergeben wird) die Zusatzinformationen (wx - Clientdata) übergeben 438 @type eintragNull: Liste 439 @param wxObj: Es ist das C{wx-Objekt} zu übergeben, welches Datenbankwerte aufnimmt (darstellt). 440 @type wxObj: C{wx-Objekt} 441 """ 442 443 444 # 445 # Datenbank abfragen, wxObj initialisieren 446 # 447 if len( eintragNull ) == 2: 448 wxObj.nimmWert( wert = eintragNull[0], clientData = eintragNull[1] ) 449 450 self.__dbAbfrage__( sql ) 451 452 for i in range( self.__gibAnzZeilen__() ): 453 clientData = [] 454 455 for j in range( 1, self.__gibAnzSpalten__() ): 456 clientData.append( self.__gibWert__( i, j ) ) 457 458 wxObj.nimmWert( wert = str( self.__gibWert__( i, 0 ) ), clientData = clientData )

459 460 461 462 463 # 464 # ------------------------------------------------------------------------------------ 465 # -- Tabellen-, Spaltenname entsprechend Fremdschlüsseldefinition ---------- 466 # -- zurückgeben ---------- 467 # ------------------------------------------------------------------------------------ 468 #

469 - def __liesTabSpFremdschluessel__( self, zielSpalte ):

470 """ 471 Es wird die Liste der Tabellen- und Spaltennamen die auf C{zielSpalte} referenzieren. 472 473 @param zielSpalte: Es ist der vollständige Datenbankspaltenname anzugeben, auf den mittels Fremdschlüssel verwiesen wird. 474 @type zielSpalte: Zeichenkette 475 476 @return: Es wird die Liste C{[Tabellenname, Spaltenname]} zurückgegeben. 477 @rtype: Ganzzahl 478 """ 479 480 # 481 # -- Datenbank auslesen -------------------------------------------------- 482 # 483 self.__dbAbfrage__( """ 484 -- 485 -- Liste der Spaltenabhängigkeiten auslesen 486 -- 487 SELECT 488 intern.gib__stsname( 'schtab', spstart ) AS schtab 489 , intern.gib__stsname( 'sp', spstart ) AS sp 490 FROM 491 intern.zeige__fremdschluessel 492 WHERE 493 spziel = '""" + zielSpalte + """' 494 ;""" ) 495 496 497 # 498 # -- Abfrageergebnis zusammenstellen ---------------------------------- 499 # 500 erg = [] 501 for i in range( self.__gibAnzZeilen__() ): 502 503 erg.append( [ self.__gibWert__( i, 0 ) 504 , self.__gibWert__( i, 1 ) ] ) 505 506 507 # 508 # -- Liste zurückgeben -------------------------------------------------- 509 # 510 return erg

511 512 513 514 515 # 516 # ------------------------------------------------------------------------------------ 517 # -- Die übergebene Anmerkung suchen ---------------------------------- 518 # ------------------------------------------------------------------------------------ 519 #

520 - def finde_psGefAnm( self, sprSprachenId, anmerkung ) :

521 """Es wird geprüft, ob die übergebene Anmerkung in der Datenbank zu finden ist. 522 523 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 524 @type sprSprachenId: Ganzzahl 525 526 @param anmerkung: Es ist die zu suchende Anmerkung zu übergeben. 527 @type anmerkung: Zeichenkette 528 529 @return: Es wird eine Liste der C{ps_gefanm_id} zurückgegeben, in der die Anmerkung gefunden wurde. Wird die Anmerkung nicht gefunden, wird C{None} zurückgegeben. 530 @rtype: Python-Liste 531 """ 532 533 # 534 # -- SQL-Abfrage ausführen -------------------------------------------------- 535 # 536 self.__dbAbfrage__( """ 537 -- 538 -- Anmerkungen - es wird der jeweils letzte zugeordnete Eintrag angezeigt 539 -- (Logbuchfunktion) 540 -- 541 SELECT DISTINCT 542 -- 0 543 prj.zeige__pl_psgefanm.ps_anmerkung_id 544 FROM 545 prj.zeige__pl_psgefanm_le 546 , prj.zeige__pl_psgefanm 547 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 548 prj.zeige__pl_psgefanm.spr_uebvar_id = 549 spr.zeige__wgruppe.spr_uebvar_id 550 AND 551 -- 552 -- Sprache Auswählen 553 -- 554 spr.zeige__wgruppe.spr_sprachen_id = """ 555 + str( sprSprachenId ) + """ ) 556 WHERE 557 -- 558 -- Ausschließlich die letzten (aktuellen) Anmerkungen anzeigen, ... 559 -- 560 prj.zeige__pl_psgefanm_le.prj__pl_psgefanm__id = 561 prj.zeige__pl_psgefanm.id 562 AND 563 -- 564 -- ... die nicht entfernt wurden 565 -- 566 prj.zeige__pl_psgefanm.logentfernt = false 567 AND 568 spr.zeige__wgruppe.wgruppe = '""" + anmerkung.encode('utf-8') + """' 569 ;""" ) 570 571 572 # 573 # -- Anmerkung wurde nicht gefunden ------------------------------------------ 574 # 575 if( self.__gibAnzZeilen__() == 0 ) : return None 576 577 578 # 579 # -- Abfrageergebnis zusammenstellen ---------------------------------- 580 # 581 erg = [] 582 for i in range( self.__gibAnzZeilen__() ): 583 584 erg.append( self.__gibWert__( i, 0 ) ) 585 586 587 # 588 # -- Id's zurückgeben -------------------------------------------------- 589 # 590 return erg

591 592 593 594 # 595 # ------------------------------------------------------------------------------------ 596 # -- Liste der aktuell zugeordneten gefährdeten Personen zurückgeben -- 597 # ------------------------------------------------------------------------------------ 598 #

599 - def gibListePsAbkId( self, prjProjekteId, sprSprachenId, psGefszenarioId, psAbkTyp ):

600 """ 601 Methode, die Datenbank-Identifikationsnummern der gefährdeten Personene zurückgibt. 602 603 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 604 @type prjProjekteId: Ganzzahl 605 606 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 607 @type sprSprachenId: Ganzzahl 608 609 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 610 @type psGefszenarioId: Ganzzahl 611 612 @param psAbkTyp: Es ist der Typ der Abkürzung (C{ps.abk.typ}) zu übergeben. 613 @type psAbkTyp: Zeichenkette 614 """ 615 616 # 617 # -- SQL-Abfrage ausführen -------------------------------------------------- 618 # 619 self.__dbAbfrage__( self.gibSQL_prjPlPsGefabk( prjProjekteId = prjProjekteId 620 , sprSprachenId = sprSprachenId 621 , psGefszenarioId = psGefszenarioId ) ) 622 623 624 # 625 # -- Liste zusammenstellen -------------------------------------------------- 626 # 627 erg = [] 628 for i in range( self.__gibAnzZeilen__() ): 629 typ = self.__gibWert__( i, 0 ) 630 631 # 632 # -- gefährdete Personen -------------------------- 633 # -- (es werden mehrere Werte gesetzt) -------------------------- 634 # 635 if typ == psAbkTyp : 636 637 erg.append( self.__gibWert__( i, 1 ) ) 638 continue 639 640 641 # 642 # -- Liste zurückgeben -------------------------------------------------- 643 # 644 return erg

645 646 647 648 # 649 # ------------------------------------------------------------------------------------ 650 # -- Liste der aktuell zugeordneten gefährdeten Personen zurückgeben -- 651 # ------------------------------------------------------------------------------------ 652 #

653 - def gibListePsGefStrktId( self, prjProjekteId, psGefszenarioId, strNameId ):

654 """ 655 Methode, die Datenbank-Identifikationsnummern der gefährdeten Personene zurückgibt. 656 657 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 658 @type prjProjekteId: Ganzzahl 659 660 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 661 @type psGefszenarioId: Ganzzahl 662 663 @param strNameId: Es ist die Datenbankidentifikationsnummer (C{str.name.id}) der Strukturbezeichnung zu übergeben 664 @type strNameId: Ganzzahl 665 """ 666 667 # 668 # -- Datenbankabfrage ausführen ------------------------------------------ 669 # 670 self.__dbAbfrage__( """ 671 -- 672 -- Strukturpunkte - es wird der jeweils letzte zugeordnete Eintrag angezeigt 673 -- (Logbuchfunktion) 674 -- 675 SELECT 676 -- 0 677 prj.zeige__pl_psgefstrkt.str_strkt_id AS strkt_id 678 -- 679 -- Kontrolle 680 -- 681 --, prj.zeige__pl_psgefstrkt.logdatuhrz AS datuhrz 682 FROM 683 prj.zeige__pl_psgefstrkt_le 684 , prj.zeige__pl_psgefstrkt 685 , str.strkt 686 WHERE 687 -- 688 -- Ausschließlich die letzten (aktuellen) Strukturpunkte anzeigen, ... 689 -- 690 prj.zeige__pl_psgefstrkt_le.prj__pl_psgefstrkt__id = 691 prj.zeige__pl_psgefstrkt.id 692 AND 693 -- 694 -- ... die nicht entfernt wurden 695 -- 696 prj.zeige__pl_psgefstrkt.logentfernt = false 697 AND 698 -- 699 -- Projekt auswählen 700 -- 701 prj.zeige__pl_psgefstrkt.prj_projekte_id = """ 702 + str( prjProjekteId ) + """ 703 AND 704 -- 705 -- Gefahrenszenario auswählen 706 -- 707 prj.zeige__pl_psgefstrkt.ps_gefszenario_id = """ 708 + str( psGefszenarioId ) + """ 709 AND 710 -- 711 -- Strukturnamen auswählen 712 -- 713 prj.zeige__pl_psgefstrkt.str_strkt_id = str.strkt.id 714 AND 715 str.strkt.str_name_id = """ + str( strNameId ) + """ 716 ;""" ) 717 718 719 720 # 721 # -- Liste zusammenstellen -------------------------------------------------- 722 # 723 erg = [] 724 for i in range( self.__gibAnzZeilen__() ): 725 726 erg.append( self.__gibWert__( i, 0 ) ) 727 728 729 # 730 # -- Liste zurückgeben -------------------------------------------------- 731 # 732 return erg

733 734 735 736 737 # 738 # ------------------------------------------------------------------------------------ 739 # -- Spaltennamen anhand der Objekt-Id (die Objekt-Id ---------- 740 # -- ist die dem wx.Window zugeordnete Identifikationsnummer) ---------- 741 # -- unter Berücksichtigung einer Projektauswahl zurückgeben ---------- 742 # ------------------------------------------------------------------------------------ 743 #

744 - def gibSpaltenName( self, wxWindowId ):

745 """Methode zur Rückgabe des C{PostgreSQL-Spaltennamens}. Der Spaltenname wird anhand der Identifikationsnummer C{wxWindowId} des Objektes zurückgegeben, welches den Inhalt der Spalte in C{wxvf} darstellt. Wenn C{keinProjekt == false}, wird die Spalte zurückgegeben, welche den projektspezifisch modifizierten Wert aufnimmt. 746 747 @param wxWindowId: Es ist die Identifikationsnummer des Objektes anzugeben, welches den Inhalt der Spalte darstellt 748 @type wxWindowId: wxPython - wx.Window - Id 749 750 @return: Es wird der Spaltenname zurückgegeben. 751 @rtype: Zeichenkette 752 """ 753 754 755 # 756 # -- Spaltennamen zurückgeben ------------------------------------------ 757 # 758 # 759 # -- prj - Projekte ---------------------------------------------------------- 760 # 761 if wxWindowId == -206 : return "prj.projekte.id" 762 763 # 764 # -- prt - Protokoll / prj - Projekte ---------------------------------- 765 # 766 if wxWindowId == -307 : return "prj.pp_prtprotokoll.datuhrz" 767 elif wxWindowId == -321 : return "prj.pp_prtprotokoll.duanfrage" 768 elif wxWindowId == -303 : return "prj.pp_prtprotokoll.erledigt" 769 elif wxWindowId == -301 : return "prj.pp_prtprotokoll.intern" 770 elif ( wxWindowId == -311 771 or wxWindowId == -312 772 or wxWindowId == -327 773 or wxWindowId == -328 ): return "prj.pp_prtprotokoll.prj_personen_id" 774 elif wxWindowId == -323 : return "prj.pp_prtprotokoll.termin" 775 776 elif wxWindowId == -299 : return "prt.protokoll.id" 777 elif wxWindowId == -316 : return "prj.pp_prtprotokoll.spr_uebvar_id" 778 elif wxWindowId == -318 : return "prj.pp_prtprotokoll.notizen" 779 780 elif wxWindowId == -305 : return "prt.typ.id" 781 782 # 783 # -- ps - Produktsicherheit / prj - Projekte ---------------------------------- 784 # 785 if ( wxWindowId == -236 786 or wxWindowId == -237 787 or wxWindowId == -268 788 or wxWindowId == -277 789 or wxWindowId == -286 ): return "prj.pl_psgefabk.ps_abk_id" 790 elif ( wxWindowId == -272 791 or wxWindowId == -281 792 or wxWindowId == -290 ): return "prj.pl_psgefabk.spr_uebvar_id_zus" 793 elif ( wxWindowId == -274 794 or wxWindowId == -283 795 or wxWindowId == -292 ): return "prj.pl_psgefabk.notizen" 796 797 if wxWindowId == -249 : return "prj.pl_psgefanm.notizen" 798 elif wxWindowId == -248 : return "prj.pl_psgefanm.spr_uebvar_id" 799 800 if ( wxWindowId == -255 801 or wxWindowId == -256 802 or wxWindowId == -260 803 or wxWindowId == -261 ): return "prj.pl_prtpsgefszenario.prt_protokoll_id" 804 805 if ( wxWindowId == -231 806 or wxWindowId == -232 ): return "ps.gefstrkt.str_strkt_id" 807 808 if wxWindowId == -221 : return "ps.gefszenario.id" 809 elif wxWindowId == -243 : return "prj.pp_psgefszenario.notizen" 810 elif wxWindowId == -241 : return "prj.pp_psgefszenario.spr_uebvar_id" 811 812 elif wxWindowId == -227 : return "prj.pp_psgefszenario.spr_uebvar_id_ursp" 813 814 elif wxWindowId == -265 : return "prj.pp_psgefszenario.spr_uebvar_id_reprgefszen" 815 816 # 817 # -- spr - Sprachen ---------------------------------------------------------- 818 # 819 if wxWindowId == -208: return "spr.sprachen.id" 820 821 # 822 # -- nichtbehandelte >wxWindowId< ------------------------------------------ 823 # 824 return ""

825 826 827 828 829 830 # 831 # ------------------------------------------------------------------------------------ 832 # -- SQL-Abfrage zur Selektion der Strukturpunkte -------------------------- 833 # ------------------------------------------------------------------------------------ 834 #

835 - def gibSQL_prjPlPrtPsGefszenario( self, prjProjekteId, psGefszenarioId, sqlINpsGefszenId = True ):

836 """ 837 Methode, die die SQL-Abfrage zurückgibt, die die Protokolleinträge auswählt, die dem Gefahrenszenario / weiteren Gefahrenszenarien im Projekt zugeordnet sind. 838 839 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 840 @type prjProjekteId: Ganzzahl 841 842 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 843 @type psGefszenarioId: Ganzzahl 844 845 @param internFirmaId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 846 @type internFirmaId: Ganzzahl 847 848 @param sqlINpsGefszenId: Wenn C{True} angegeben wird, werden die Protokolleinträge zum Gefahrenszenario ausgewählt. Sonst nicht. 849 @type sqlINpsGefszenId: Boolean 850 """ 851 852 # 853 # -- SQL-Abfrage zurückgeben ------------------------------------------ 854 # 855 sqlNOT = '' 856 if( not sqlINpsGefszenId ) : sqlNOT = 'NOT ' 857 858 return( """ 859 SELECT DISTINCT 860 prt_protokoll_id 861 FROM 862 prj.zeige__pl_prtpsgefszenario 863 , prj.zeige__pl_prtpsgefszenario_le 864 WHERE 865 prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id = 866 prj.zeige__pl_prtpsgefszenario.id 867 AND 868 prj.zeige__pl_prtpsgefszenario.logentfernt = false 869 AND 870 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id """ + sqlNOT + """IN( """ 871 + str( psGefszenarioId ) + """ ) 872 AND 873 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ + str( prjProjekteId ) + """ 874 ;""" )

875 876 # 877 # -- später einführen -------------------------------------------------- 878 # 879 # return( self.gibSQLSelect( 880 # select = """ 881 #SELECT DISTINCT 882 # prt_protokoll_id""" 883 # , tabellen = [ self.gibSQLSelect__PlPrtPsGefszenario( sqlJOIN = None 884 # , sqlWHERE = """ 885 #AND 886 # prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id """ + sqlNOT + """IN( """ 887 # + str( psGefszenarioId ) + """ ) 888 #AND 889 # prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ + str( prjProjekteId ) ) ] ) ) 890 891 892 893 894 895 896 # 897 # ------------------------------------------------------------------------------------ 898 # -- SQL-Abfrage zur Selektion der Abkürzungen -------------------------- 899 # ------------------------------------------------------------------------------------ 900 #

901 - def gibSQL_prjPlPsGefabk( self, prjProjekteId, sprSprachenId, psGefszenarioId ):

902 """ 903 Methode, die die SQL-Abfrage zurückgibt, die Abkürzungen auswählt, die dem Gefahrenszenario im Projekt zugeordnet sind. 904 905 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 906 @type prjProjekteId: Ganzzahl 907 908 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 909 @type sprSprachenId: Ganzzahl 910 911 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 912 @type psGefszenarioId: Ganzzahl 913 """ 914 915 # 916 # -- SQL-Abfrage zurückgeben ------------------------------------------ 917 # 918 return(""" 919 -- 920 -- Abkürzungen - es wird der jeweils letzte zugeordnete Eintrag angezeigt 921 -- (Logbuchfunktion) 922 -- 923 SELECT 924 -- 0 925 prj.zeige__psabk.ps__abk__typ AS abk_typ 926 , prj.zeige__pl_psgefabk.ps_abk_id AS abk_id 927 -- 2 928 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS begr 929 , prj.zeige__pl_psgefabk.notizen 930 -- 4 931 , prj.zeige__pl_psgefabk.spr_uebvar_id_zus 932 -- 933 -- Kontrolle 934 -- 935 --, prj.zeige__pl_psgefabk.logdatuhrz AS datuhrz 936 FROM 937 prj.zeige__pl_psgefabk_le 938 , prj.zeige__pl_psgefabk 939 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 940 prj.zeige__pl_psgefabk.spr_uebvar_id_zus = 941 spr.zeige__wgruppe.spr_uebvar_id 942 AND 943 -- 944 -- Sprache Auswählen 945 -- 946 spr.zeige__wgruppe.spr_sprachen_id = """ 947 + str( sprSprachenId ) + """ 948 ) 949 , prj.zeige__psabk 950 WHERE 951 -- 952 -- Ausschließlich die letzten (aktuellen) Abkürzungen anzeigen, ... 953 -- 954 prj.zeige__pl_psgefabk_le.prj__pl_psgefabk__id = 955 prj.zeige__pl_psgefabk.id 956 AND 957 -- 958 -- ... die nicht entfernt wurden 959 -- 960 prj.zeige__pl_psgefabk.logentfernt = false 961 AND 962 -- 963 -- Projekt auswählen 964 -- 965 prj.zeige__pl_psgefabk.prj_projekte_id = """ 966 + str( prjProjekteId ) + """ 967 AND 968 -- 969 -- Gefahrenszenario auswählen 970 -- 971 prj.zeige__pl_psgefabk.ps_gefszenario_id = """ + str( psGefszenarioId ) + """ 972 AND 973 -- 974 -- Typ der Abkürzung zuordnen 975 -- 976 prj.zeige__pl_psgefabk.ps_abk_id = prj.zeige__psabk.ps__abk__id 977 AND 978 prj.zeige__pl_psgefabk.prj_projekte_id = 979 prj.zeige__psabk.prj__p_psabk__prj_projekte_id 980 ORDER BY 981 prj.zeige__psabk.ps__abk__typ 982 ;""")

983 984 985 986 987 988 989 990 991 # 992 # ------------------------------------------------------------------------------------ 993 # -- SQL-Abfrage zur Selektion der Strukturpunkte -------------------------- 994 # ------------------------------------------------------------------------------------ 995 #

996 - def gibSQL_prjPrtDoku( self, prjProjekteId, sprSprachenId, prtProtokollId, psGefszenarioId, internFirmaId ):

997 """ 998 Methode, die die SQL-Abfrage zurückgibt, die die Dokumente auswählt, die einem Protokolleintrag, einer Sicherheitsanforderung, Terminplaneintrag oder Gefarenszenario zugeordnet sind. 999 1000 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 1001 @type prjProjekteId: Ganzzahl 1002 1003 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 1004 @type sprSprachenId: Ganzzahl 1005 1006 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 1007 @type prtProtokollId: Ganzzahl 1008 1009 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 1010 @type psGefszenarioId: Ganzzahl 1011 1012 @param internFirmaId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 1013 @type internFirmaId: Ganzzahl 1014 """ 1015 1016 # 1017 # -- SQL-Abfrageergebnis einschränken ---------------------------------- 1018 # 1019 projekt = "" 1020 protokoll = "" 1021 gefszenario = "" 1022 firma = "" 1023 1024 if( prjProjekteId is not None ) : 1025 projekt = """ 1026 AND 1027 -- 1028 -- Projekt festlegen 1029 -- 1030 prj.zeige__dokdoku.prj__pl_prtdokdoku__prj_projekte_id = """ + str( prjProjekteId ) + """ 1031 """ 1032 1033 if( prtProtokollId is not None ) : 1034 protokoll = """ 1035 AND 1036 -- 1037 -- Protokolleinträge festlegen 1038 -- 1039 prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id IN( """ + str( prtProtokollId ) + """ ) 1040 """ 1041 1042 if( psGefszenarioId is not None ) : 1043 gefszenario = """ 1044 AND 1045 -- 1046 -- Gefahrenszenarien festlegen 1047 -- 1048 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id = """ + str( psGefszenarioId ) + """ 1049 """ 1050 1051 if( internFirmaId is not None ) : 1052 firma = """ 1053 AND 1054 -- 1055 -- Firma einschränken 1056 -- 1057 prj.zeige__dokdoku.dok__doku__intern_firma_id = """ + str( internFirmaId ) + """ 1058 """ 1059 1060 1061 return( """ 1062 -- 1063 -- Dokumente anzeigen 1064 -- 1065 SELECT DISTINCT 1066 -- 0 1067 prj.zeige__dokdoku.dok__doku__id 1068 , prj.zeige__dokdoku.dok__doku__notizen AS dok_notizen 1069 -- 2 1070 , prj.zeige__dokdoku.prj__pl_prtdokdoku__nr 1071 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS titel 1072 -- 4 1073 , prj.zeige__dokdoku.prj__pl_prtdokdoku__notizen AS prj_notizen 1074 , ausgabe.prj__pl_dokausgabe__stand AS stand 1075 -- 6 1076 , ausgabe.prj__pl_dokausgabe__datum AS datum 1077 , ausgabe.prj__pl_dokausgabe__notizen AS ausg_notizen 1078 -- 8 1079 , prj.zeige__dokdoku.dok__doku__aspekt AS dok_aspekt 1080 , COALESCE( zus.wgruppe, '??' ) AS zus 1081 -- 10 1082 , prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id 1083 , prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id_zus 1084 -- 12 1085 , ausgabe.prj__pl_dokausgabe__istfrei AS istfrei 1086 , prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id 1087 FROM 1088 prj.zeige__pl_prtpsgefszenario 1089 , prj.zeige__pl_prtpsgefszenario_le 1090 , prj.zeige__pl_prtdokdoku_le 1091 , prj.zeige__dokdoku 1092 -- 1093 -- Dokumententitel 1094 -- 1095 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 1096 prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id = 1097 spr.zeige__wgruppe.spr_uebvar_id 1098 AND 1099 -- 1100 -- Sprache Auswählen 1101 -- 1102 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1103 ) 1104 -- 1105 -- Zusatzinformationen 1106 -- 1107 LEFT OUTER JOIN spr.zeige__wgruppe AS zus ON ( 1108 prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id_zus = 1109 zus.spr_uebvar_id 1110 AND 1111 -- 1112 -- Sprache Auswählen 1113 -- 1114 zus.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1115 ) 1116 -- 1117 -- Ausgaben 1118 -- 1119 LEFT OUTER JOIN prj.zeige__dokdoku AS ausgabe ON ( 1120 prj.zeige__dokdoku.dok__doku__id = ausgabe.dok__doku__id 1121 AND 1122 -- 1123 -- Die Ausgaben wurden nicht entfernt 1124 -- 1125 ausgabe.prj__pl_dokausgabe__logentfernt = false 1126 1127 AND 1128 -- 1129 -- Projekte müssen übereinstimmen 1130 -- 1131 prj.zeige__dokdoku.prj__pl_prtdokdoku__prj_projekte_id = 1132 ausgabe.prj__pl_prtdokdoku__prj_projekte_id 1133 ) 1134 -- 1135 -- Ausschließlich die letzten (aktuellen) Ausgaben anzeigen 1136 -- 1137 INNER JOIN prj.zeige__pl_dokausgabe_le ON ( 1138 prj.zeige__pl_dokausgabe_le.prj__pl_dokausgabe__id = 1139 ausgabe.prj__pl_dokausgabe__id 1140 ) 1141 WHERE 1142 -- 1143 -- Gefahrenszenarien und Protokolleinträge verbinden 1144 -- 1145 prj.zeige__pl_prtpsgefszenario.id = prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id 1146 AND 1147 prj.zeige__pl_prtpsgefszenario.logentfernt = false 1148 AND 1149 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id = prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id 1150 AND 1151 -- 1152 -- Ausschließlich die letzten (aktuellen) Dokumente anzeigen, ... 1153 -- 1154 prj.zeige__pl_prtdokdoku_le.prj__pl_prtdokdoku__id = 1155 prj.zeige__dokdoku.prj__pl_prtdokdoku__id 1156 AND 1157 -- 1158 -- ... die nicht entfernt wurden 1159 -- 1160 prj.zeige__dokdoku.prj__pl_prtdokdoku__logentfernt = false 1161 AND 1162 -- 1163 -- Nulldokument nicht zeigen 1164 -- 1165 prj.zeige__dokdoku.dok__doku__id > 0""" 1166 + projekt 1167 + protokoll 1168 + gefszenario 1169 + firma 1170 + """ 1171 1172 UNION 1173 1174 -- 1175 -- Dokumente anzeigen 1176 -- 1177 SELECT DISTINCT 1178 -- 1179 -- Dokumente 1180 -- 1181 prj.zeige__dokdoku.dok__doku__id 1182 , prj.zeige__dokdoku.dok__doku__notizen 1183 , prj.zeige__dokdoku.prj__pl_prtdokdoku__nr 1184 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) 1185 , prj.zeige__dokdoku.prj__pl_prtdokdoku__notizen 1186 -- 1187 -- Ausgaben 1188 -- 1189 , NULL AS stand 1190 , CAST( NULL AS date ) AS datum 1191 , NULL AS ausg_notizen 1192 -- 1193 -- Dokumente 1194 -- 1195 , prj.zeige__dokdoku.dok__doku__aspekt AS dok_aspekt 1196 , COALESCE( zus.wgruppe, '??' ) AS zus 1197 , prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id 1198 , prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id_zus 1199 -- 1200 -- Ausgaben 1201 -- 1202 , CAST( NULL AS boolean ) AS istfrei 1203 , prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id 1204 FROM 1205 prj.zeige__pl_prtpsgefszenario 1206 , prj.zeige__pl_prtpsgefszenario_le 1207 , prj.zeige__pl_prtdokdoku_le 1208 , prj.zeige__dokdoku 1209 -- 1210 -- Dokumententitel 1211 -- 1212 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 1213 prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id = 1214 spr.zeige__wgruppe.spr_uebvar_id 1215 AND 1216 -- 1217 -- Sprache Auswählen 1218 -- 1219 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1220 ) 1221 -- 1222 -- Zusatzinformationen 1223 -- 1224 LEFT OUTER JOIN spr.zeige__wgruppe AS zus ON ( 1225 prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id_zus = 1226 zus.spr_uebvar_id 1227 AND 1228 -- 1229 -- Sprache Auswählen 1230 -- 1231 zus.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1232 ) 1233 WHERE 1234 -- 1235 -- Gefahrenszenarien und Protokolleinträge verbinden 1236 -- 1237 prj.zeige__pl_prtpsgefszenario.id = prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id 1238 AND 1239 prj.zeige__pl_prtpsgefszenario.logentfernt = false 1240 AND 1241 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id = prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id 1242 AND 1243 -- 1244 -- Ausschließlich die letzten (aktuellen) Dokumente anzeigen, ... 1245 -- 1246 prj.zeige__pl_prtdokdoku_le.prj__pl_prtdokdoku__id = 1247 prj.zeige__dokdoku.prj__pl_prtdokdoku__id 1248 AND 1249 -- 1250 -- ... die nicht entfernt wurden 1251 -- 1252 prj.zeige__dokdoku.prj__pl_prtdokdoku__logentfernt = false 1253 AND 1254 -- 1255 -- Nulldokument nicht zeigen 1256 -- 1257 prj.zeige__dokdoku.dok__doku__id > 0 1258 AND 1259 -- 1260 -- Dokumente, denen noch keine Ausgabe zugeordnet ist 1261 -- 1262 prj.zeige__dokdoku.prj__pl_dokausgabe__id IS NULL""" 1263 + projekt 1264 + protokoll 1265 + gefszenario 1266 + firma 1267 + """;""" )

1268 1269 1270 1271 # 1272 # ------------------------------------------------------------------------------------ 1273 # -- SQL-Abfrage zur Selektion der Protokolleinträge -------------------------- 1274 # ------------------------------------------------------------------------------------ 1275 #

1276 - def gibSQL_psPrtProtokoll( self, prjProjekteId, sprSprachenId, prtTypAspekt, psGefszenarioId, sqlINpsGefszenId = True, prtProtokollIdVorg = None, prtProtokollIdNachf = None ):

1277 """ 1278 Methode, die die SQL-Abfrage zurückgibt, die Detailinformationen zu Protokolleinträgen, Sicherheitsanforderungen oder Terminplaneinträgen aus der Datenbank liest. 1279 1280 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 1281 @type prjProjekteId: Ganzzahl 1282 1283 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 1284 @type sprSprachenId: Ganzzahl 1285 1286 @param prtTypAspekt: Es ist der Aspekt des Protokolleintrages (C{prt.typ.aspekt}) zu übergeben. 1287 @type prtTypAspekt: Zeichenkette 1288 1289 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 1290 @type psGefszenarioId: Ganzzahl 1291 1292 @param sqlINpsGefszenId: Wenn C{True} angegeben wird, werden die Protokolleinträge zum Gefahrenszenario ausgewählt. Sonst nicht. 1293 @type sqlINpsGefszenId: Boolean 1294 1295 @param prtProtokollIdVorg: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 1296 @type prtProtokollIdVorg: Ganzzahl(liste) 1297 1298 @param prtProtokollIdNachf: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 1299 @type prtProtokollIdNachf: Ganzzahl(liste) 1300 1301 @return: Es wird die SQL-Abfrage zurückgegeben. 1302 @rtype: Zeichenette 1303 """ 1304 1305 # 1306 # -- Vorgänger / Nachfolger einschränken ------------------------------------------ 1307 # 1308 sqlAND = '' 1309 1310 if( prtProtokollIdVorg is not None ) : 1311 1312 sqlAND = ( """ 1313 AND 1314 -- 1315 -- Vorgänger auswählen 1316 -- 1317 prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prt_protokoll_id_vorg IN( """ 1318 + str( prtProtokollIdVorg ) + " )" ) 1319 1320 if( prtProtokollIdNachf is not None ) : 1321 1322 sqlAND = sqlAND + ( """ 1323 AND 1324 -- 1325 -- Vorgänger auswählen 1326 -- 1327 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id IN( """ 1328 + str( prtProtokollIdNachf ) + " )" ) 1329 1330 1331 1332 # 1333 # -- SQL-Abfrage zurückgeben ------------------------------------------ 1334 # 1335 sqlNOT = '' 1336 if( not sqlINpsGefszenId ) : sqlNOT = 'NOT ' 1337 1338 return( """ 1339 -- 1340 -- Protokolleinträge - es wird der jeweils letzte zugeordnete Eintrag angezeigt 1341 -- (Logbuchfunktion) 1342 -- 1343 SELECT DISTINCT 1344 -- 0 1345 prj.zeige__pl_prtpsgefszenario.id AS gefprot_id 1346 , prj.zeige__prtprotokoll.prt__typ__id AS typ_id 1347 -- 2 1348 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS proteintrag 1349 , prj.zeige__pl_prtpsgefszenario.prt_protokoll_id AS protokoll_id 1350 -- 4 1351 , prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prt_protokoll_id_vorg AS protokoll_id_vorg 1352 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id 1353 -- 6 1354 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen 1355 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__id 1356 -- 1357 -- Kontrolle 1358 -- 1359 --, prj.zeige__pl_prtpsgefszenario.logdatuhrz AS datuhrz 1360 --, prj.zeige__prtprotokoll.prt__typ__aspekt AS aspekt 1361 FROM 1362 prj.zeige__pl_prtpsgefszenario_le 1363 , prj.zeige__pl_prtpsgefszenario 1364 , prj.zeige__prtprotokoll 1365 -- 1366 -- Text der Protokolleinträge darstellen 1367 -- 1368 LEFT OUTER JOIN spr.zeige__wgruppe 1369 ON ( 1370 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id = 1371 spr.zeige__wgruppe.spr_uebvar_id 1372 AND 1373 -- 1374 -- Sprache Auswählen 1375 -- 1376 spr.zeige__wgruppe.spr_sprachen_id = """ 1377 + str( sprSprachenId ) + """ 1378 ) 1379 -- 1380 -- Vorgänger zum Protokolleintrag anzeigen 1381 -- 1382 LEFT OUTER JOIN prj.zeige__prtprotokolltabellen 1383 ON ( 1384 prj.zeige__prtprotokolltabellen.prt__protokoll__id = 1385 prj.zeige__prtprotokoll.prt__protokoll__id 1386 AND 1387 prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prj_projekte_id = 1388 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id 1389 ) 1390 WHERE 1391 -- 1392 -- Protokolleinträge auf letzte Einträge beschränken 1393 -- 1394 prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id = 1395 prj.zeige__pl_prtpsgefszenario.id 1396 AND 1397 -- 1398 -- die Detailinformationen (Gefahrenszenario, Projekt, Aspekt) zu den 1399 -- Protokolleinträgen holen 1400 -- 1401 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_personen_id = 0 1402 AND 1403 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id = 1404 prj.zeige__prtprotokoll.prt__protokoll__id 1405 AND 1406 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = 1407 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id 1408 AND 1409 -- 1410 -- die nichtgelöschten Einträge zeigen 1411 -- 1412 prj.zeige__pl_prtpsgefszenario.logentfernt = false 1413 AND 1414 -- 1415 -- Projekt auswählen 1416 -- 1417 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ 1418 + str( prjProjekteId ) + """ 1419 AND 1420 -- 1421 -- Gefahrenszenario auswählen 1422 -- 1423 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id """ + sqlNOT + """IN( """ 1424 + str( psGefszenarioId ) + """ ) 1425 AND 1426 -- 1427 -- Aspekt auswählen 1428 -- 1429 prj.zeige__prtprotokoll.prt__typ__aspekt = '""" + str( prtTypAspekt ) + "'" 1430 1431 + sqlAND + """ 1432 ;""" )

1433 1434 1435 1436 1437 # 1438 # ------------------------------------------------------------------------------------ 1439 # -- SQL-Abfrage zur Selektion der Strukturpunkte -------------------------- 1440 # ------------------------------------------------------------------------------------ 1441 #

1442 - def gibSQL_psPrtStrkt( self, prjProjekteId, sprSprachenId, prtProtokollId, psGefszenarioId, strNameId, gibPersonen = False ):

1443 """ 1444 Methode, die die SQL-Abfrage zurückgibt, die die Strukturpunkte auswählt, die einem Protokolleintrag, einer Sicherheitsanforderung, Terminplaneintrag oder Gefarenszenario zugeordnet sind. 1445 1446 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 1447 @type prjProjekteId: Ganzzahl 1448 1449 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 1450 @type sprSprachenId: Ganzzahl 1451 1452 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 1453 @type prtProtokollId: Ganzzahl 1454 1455 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 1456 @type psGefszenarioId: Ganzzahl 1457 1458 @param strNameId: Es ist die Datenbankidentifikationsnummer (C{str.name.id}) der Strukturbezeichnung zu übergeben, die dargestellt werden soll. 1459 @type strNameId: Ganzzahl 1460 1461 @return: Es wird die SQL-Abfrage zurückgegeben. 1462 @rtype: Zeichenette 1463 """ 1464 1465 # 1466 # -- SQL-Abfrageergebnis einschränken ---------------------------------- 1467 # 1468 strName = "" 1469 gefszenProt = "" 1470 selectProtokoll = "" 1471 protokollGefszenario = "" 1472 1473 1474 # 1475 # -- Strukturnamen einschränken ------------------------------------------ 1476 # 1477 if( strNameId is not None ) : 1478 strName = """ 1479 AND 1480 -- 1481 -- -- Strukturnamen auswählen ---------------------------------- 1482 -- 1483 prj.zeige__strstrkt.str__name__id = """ + str( strNameId ) + """ 1484 """ 1485 1486 1487 # 1488 # -- Projekt einschränken -------------------------------------------------- 1489 # 1490 if( prtProtokollId is None 1491 and psGefszenarioId is None ) : 1492 1493 protokollGefszenario = """ 1494 AND 1495 -- 1496 -- -- Projekt auswählen ------------------------------------------ 1497 -- 1498 prj.zeige__strstrkt.prj_projekte_id = """ + str( prjProjekteId ) 1499 1500 1501 # 1502 # -- Protokolleintrag / Gefahrenszenario einschränken ------------------ 1503 # 1504 if( prtProtokollId is not None 1505 or psGefszenarioId is not None ) : 1506 gefszenProt = """ 1507 -- 1508 -- -- Variabler Teil -------------------------------------------------- 1509 -- 1510 , prj.zeige__prtprotokolltabellen 1511 """ 1512 1513 protokollGefszenario = """ 1514 1515 -- 1516 -- -- Protokoll-Id / Gefahren-Id einschränken ------------------ 1517 -- 1518 AND 1519 -- 1520 -- -- Strukturpunkt zuordnen ------------------------------------------ 1521 -- 1522 prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__str_strkt_id = 1523 prj.zeige__strstrkt.str__strkt__id 1524 AND 1525 -- 1526 -- -- Projekt zuordnen ------------------------------------------ 1527 -- 1528 prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__prj_projekte_id = 1529 prj.zeige__strstrkt.prj_projekte_id 1530 AND 1531 -- 1532 -- -- Protokoll auswählen / zuordnen ---------------------------------- 1533 -- 1534 prj.zeige__prtprotokolltabellen.prt__protokoll__id IN( """ 1535 1536 1537 # 1538 # -- Protokolleintrag einschränken ------------------------------------------ 1539 # 1540 if( prtProtokollId is not None ) : 1541 1542 protokollGefszenario = protokollGefszenario + str( prtProtokollId ) + """ )""" 1543 1544 if( prjProjekteId is not None ) : 1545 1546 selectProtokoll = """ 1547 , prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__id""" 1548 1549 protokollGefszenario = protokollGefszenario + """ 1550 AND 1551 -- 1552 -- -- Projekt auswählen ------------------------------------------ 1553 -- 1554 prj.zeige__strstrkt.prj_projekte_id = """ + str( prjProjekteId ) 1555 1556 else : 1557 1558 selectProtokoll = """ 1559 , prj.zeige__prtprotokolltabellen.prt__protokoll__id""" 1560 1561 1562 # 1563 # -- die zugeordneten Personen sollen ausgegeben werden ------------------ 1564 # -- (zusätzlich wird >spr.uebvar.id< ausgegeben) ------------------ 1565 # 1566 if( gibPersonen ) : 1567 1568 selectProtokoll = selectProtokoll + """ 1569 -- 6 1570 , prj.zeige__strstrkt.prj__pp_strstrkt__prj_personen_id 1571 , prj.zeige__strstrkt.prj__pp_strstrkt__spr_uebvar_id""" 1572 1573 1574 # 1575 # -- Gefahrenszenario einschränken ------------------------------------------ 1576 # 1577 if( psGefszenarioId is not None ) : 1578 gefszenProt = gefszenProt + """ 1579 , prj.zeige__pl_prtpsgefszenario""" 1580 1581 protokollGefszenario = protokollGefszenario + """ 1582 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id ) 1583 AND 1584 -- 1585 -- -- Projekt zuordnen ------------------------------------------ 1586 -- 1587 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = 1588 prj.zeige__strstrkt.prj_projekte_id 1589 AND 1590 -- 1591 -- -- Gefahrenszenario auswählen ---------------------------------- 1592 -- 1593 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id = """ + str( psGefszenarioId ) 1594 1595 1596 # 1597 # -- SQL-Abfrage zurückgeben ------------------------------------------ 1598 # 1599 return( """ 1600 -- 1601 -- Strukturpunkte - es wird der jeweils letzte zugeordnete Eintrag angezeigt 1602 -- (Logbuchfunktion) 1603 -- 1604 SELECT DISTINCT 1605 -- 0 1606 prj.zeige__strstrkt.str__strkt__id 1607 , prj.zeige__strstrkt.str__strkt__nr || ' ' || COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS strpkt 1608 -- 2 1609 , nachfok.str__strkt__id AS str_strkt_id__vorg 1610 , prj.zeige__strstrkt.str__name__id 1611 -- 4 1612 , prj.zeige__strstrkt.str__name__name_k""" 1613 + selectProtokoll + """ 1614 -- 1615 -- ... damit ORDER BY funktioniert 1616 -- 1617 , prj.zeige__strstrkt.str__strkt__nr 1618 FROM 1619 prj.zeige__strstrkt 1620 -- 1621 -- Strukturpunkt 1622 -- 1623 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 1624 prj.zeige__strstrkt.prj__pp_strstrkt__spr_uebvar_id = 1625 spr.zeige__wgruppe.spr_uebvar_id 1626 AND 1627 -- 1628 -- Sprache Auswählen 1629 -- 1630 spr.zeige__wgruppe.spr_sprachen_id = """ 1631 + str( sprSprachenId ) + """ 1632 ) 1633 -- 1634 -- aktueller Strukturpunkt ist ein gültiger Nachfolger 1635 -- 1636 LEFT OUTER JOIN prj.zeige__strstrkt AS nachfok 1637 ON ( 1638 nachfok.prj__p_strverbindung__str_strkt_id_nachf = 1639 prj.zeige__strstrkt.str__strkt__id 1640 AND 1641 nachfok.prj_projekte_id = prj.zeige__strstrkt.prj_projekte_id 1642 ) 1643 1644 """ + gefszenProt + """ 1645 WHERE 1646 -- 1647 -- -- Gefahrennetz nicht anzeigen ---------------------------------- 1648 -- 1649 prj.zeige__strstrkt.str__name__id != 2 1650 """ 1651 + strName 1652 + protokollGefszenario 1653 + """ 1654 ORDER BY 1655 prj.zeige__strstrkt.str__name__name_k 1656 , prj.zeige__strstrkt.str__strkt__nr;""" )

1657 1658 1659 1660 # 1661 # ------------------------------------------------------------------------------------ 1662 # -- -------------------------- 1663 # -- >LEFT OUTER JOIN spr.zeige__wgruppe ...< zurückgeben ------------------ 1664 # -- ------------------ 1665 # -- -> spr.zeige__wgruppe ------------------ 1666 # -- -------------------------- 1667 # ------------------------------------------------------------------------------------ 1668 #

1669 - def gibSQL__LEFTsprZeigeWgruppe( self, spalteSprUebvarId, sprSprachenId, sqlAS = None ):

1670 """ 1671 Methode, die die Liste der Tabellenwerte für C{prj.zeige__pl_prtpsgefszenario, prj.zeige__pl_prtpsgefszenario_le} zurückgibt, die in C{gibSQLSelect(... , tabellen )} verwendet werden kann. 1672 1673 @param spalteSprUebvarId: Es ist der Spaltenname anzugeben, der mit C{spr.zeige__wgruppe.spr_uebvar_id} verknüpft wird. 1674 @type spalteSprUebvarId: Zeichenkette 1675 1676 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 1677 @type sprSprachenId: Ganzzahl 1678 1679 @param sqlAS: Es kann eine AS-Bezeichnung für C{spr.zeige__wgruppe} angegeben werden. Sie darf auch C{None} sein. 1680 @type sqlAS: Zeichenkette 1681 1682 @return: Es wird die SQL-Anweisung C{LEFT OUTER JOIN spr.zeige__wgruppe ...} zurückgegeben. 1683 @rtype: Zeichenkette 1684 """ 1685 1686 # 1687 # -- SQL-Anweisung zusammenstellen ------------------------------------------ 1688 # 1689 sql = """ 1690 -- 1691 -- Zeichenkette 1692 -- 1693 LEFT OUTER JOIN spr.zeige__wgruppe""" 1694 1695 1696 sqlASintern = "spr.zeige__wgruppe" 1697 1698 if( sqlAS is not None ) : 1699 1700 sqlASintern = sqlAS 1701 1702 sql = sql + " AS " + sqlASintern 1703 1704 1705 sql = sql + """ ON ( 1706 """ + sqlASintern + """.spr_uebvar_id = 1707 """ + spalteSprUebvarId + """ 1708 AND 1709 -- 1710 -- Sprache Auswählen 1711 -- 1712 """ + sqlASintern + """.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1713 )""" 1714 1715 # 1716 # -- SQL-Anweisung zurückgeben ------------------------------------------ 1717 # 1718 return sql

1719 1720 1721 1722 1723 1724 1725 # 1726 # ------------------------------------------------------------------------------------ 1727 # -- -------------------------------------------------- 1728 # -- generische SQL-Abfrage -------------------------------------------------- 1729 # -- -------------------------------------------------- 1730 # ------------------------------------------------------------------------------------ 1731 #

1732 - def gibSQLSelect( self, select, tabellen, sqlWHERE = None ):

1733 """ 1734 Methode, die die SQL-Abfrage zurückgibt, die ... 1735 1736 @param select: Es sind die Datenbankspalten anzugeben, die in der SQL-Select-Anweisung verwendet werden. 1737 @type select: Zeichenkette 1738 1739 @param tabellen: Es ist die Liste der Tabellen einschließlich spezifischer SQL-Anweisungen anzugeben, die in der SQL-Select-Anweisung verwendet werden. Details zu dieser Liste sind dem Quellcode zu entnehmen. 1740 @type tabellen: Python-Liste 1741 1742 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 1743 @type sqlWHERE: Zeichenkette 1744 1745 @return: Es wird die SQL-Abfrage zurückgegeben. 1746 @rtype: Zeichenette 1747 """ 1748 1749 # 1750 # -- tabellen[i][0] Tabellenname(n) - es können mehrere Tabellennamen -- 1751 # -- übergeben werden (z.B. bei Logbuchtabellen) -- 1752 # -- -- 1753 # -- tabellen[i][1] Es ist die Spalte der Projekt-Identifikationsnummern -- 1754 # -- der Tabelle anzugeben (schema.tabelle.prj_projekte_id) -- 1755 # -- -- 1756 # -- tabellen[i][2] Wenn mehrere Tabellennamen übergeben werden, ist hier -- 1757 # -- die Verbindung zwischen den Tabellen anzugeben -- 1758 # -- (darf None sein) -- 1759 # -- -- 1760 # -- tabellen[i][3] Es ist eine beliebige zusätzliche JOIN-Anweisung -- 1761 # -- anzugeben -- 1762 # -- (darf None sein) -- 1763 # -- -- 1764 # -- tabellen[i][4] Es ist eine beliebige zusätzliche WHERE-Anweisung -- 1765 # -- anzugeben -- 1766 # -- (darf None sein) -- 1767 # -- 1768 1769 # 1770 # -- FROM und WHERE zusammenstellen, die aus den Tabellen gebildet werden -- 1771 # 1772 sqlFROM = '' 1773 sqlWhereIntern = '' 1774 1775 for i in range( len( tabellen ) ) : 1776 1777 # 1778 # -- Tabellennamen ausgeben ------------------------------------------ 1779 # 1780 sqlWhereIntern = sqlWhereIntern + ( """ 1781 -- 1782 -- 1783 -- -- """ + tabellen[i][0] + """ --------------------------------- 1784 -- 1785 --""" ) 1786 1787 1788 # 1789 # -- Liste ---------------------------------------------------------- 1790 # 1791 sqlFROM = sqlFROM + '\n\t' 1792 if( i > 0 ) : 1793 sqlFROM = sqlFROM + ', ' 1794 sqlWhereIntern = sqlWhereIntern + '\nAND\n' 1795 1796 # 1797 # -- FROM ---------------------------------- 1798 # -- - Tabellenname übernehmen ---------------------------------- 1799 # -- - JOIN-Anweisung übernehmen ---------------------------------- 1800 # 1801 sqlFROM = sqlFROM + tabellen[i][0] 1802 1803 if( tabellen[i][3] is not None ) : 1804 sqlFROM = sqlFROM + tabellen[i][3] 1805 1806 # 1807 # -- WHERE -------------------------- 1808 # -- - Projekt-Id mit Tabelle 1 verbinden -------------------------- 1809 # -- - mehrere Tabellen verbinden -------------------------- 1810 # -- - WHERE-Anweisung übernehmen -------------------------- 1811 # 1812 if( i > 0 ) : 1813 sqlWhereIntern = "\t" + sqlWhereIntern + "\t" + tabellen[0][1] + " =\n\t\t" + tabellen[i][1] 1814 1815 1816 if( tabellen[i][2] is not None ) : 1817 1818 sqlWhereIntern = sqlWhereIntern + "\n" 1819 if( i > 0 ) : sqlWhereIntern = sqlWhereIntern + "AND\n" 1820 sqlWhereIntern = sqlWhereIntern + "\t" + tabellen[i][2] 1821 1822 if( tabellen[i][4] is not None ) : 1823 sqlWhereIntern = sqlWhereIntern + tabellen[i][4] 1824 1825 1826 # 1827 # -- sqlWHERE ---------------------------------------------------------- 1828 # 1829 if( sqlWHERE is not None ) : sqlWhereIntern = sqlWhereIntern + sqlWHERE 1830 1831 1832 # 1833 # -- SQL-Abfrage zurückgeben ------------------------------------------ 1834 # 1835 return( select 1836 + "\nFROM" + sqlFROM 1837 + "\nWHERE" + sqlWhereIntern 1838 + ";" )

1839 1840 1841 1842 # 1843 # ------------------------------------------------------------------------------------ 1844 # -- -------------------------- 1845 # -- Liste der Tabellenwerte für >gibSQLSelect()< -------------------------- 1846 # -- -------------------------- 1847 # -- -> prj.zeige__pl_prtpsgefszenario_le -------------------------- 1848 # -- -> prj.zeige__pl_prtpsgefszenario -------------------------- 1849 # -- -------------------------- 1850 # ------------------------------------------------------------------------------------ 1851 #

1852 - def gibSQLSelect__PlPrtPsGefszenario( self, sqlJOIN = None, sqlWHERE = None ):

1853 """ 1854 Methode, die die Liste der Tabellenwerte für C{prj.zeige__pl_prtpsgefszenario, prj.zeige__pl_prtpsgefszenario_le} zurückgibt, die in C{gibSQLSelect(... , tabellen )} verwendet werden kann. 1855 1856 @param sqlJOIN: Es kann eine JOIN-Anweisung angegeben werden. Darf auch C{None} sein. 1857 @type sqlJOIN: Zeichenkette 1858 1859 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 1860 @type sqlWHERE: Zeichenkette 1861 1862 @return: Es wird die Python-Liste für C{gibSQLSelect(... , tebellen )} zurückgegeben. 1863 @rtype: Python-Liste 1864 """ 1865 1866 # 1867 # -- Der (die) Tabellenname(n) werden immer zurückgegeben ------------------ 1868 # 1869 liste = [] 1870 liste.append( "prj.zeige__pl_prtpsgefszenario_le, prj.zeige__pl_prtpsgefszenario" ) 1871 1872 1873 # 1874 # -- Der Spaltenname der Projekt-Identifikationsnummer wird immer ---------- 1875 # -- zurückgegeben ---------- 1876 # 1877 liste.append( "prj.zeige__pl_prtpsgefszenario.prj_projekte_id" ) 1878 1879 1880 # 1881 # -- Die Vebindung zwischen beiden Tabellen zurückgegeben ------------------ 1882 # 1883 liste.append( """prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id = 1884 prj.zeige__pl_prtpsgefszenario.id 1885 AND 1886 prj.zeige__pl_prtpsgefszenario.logentfernt = false""" ) 1887 1888 1889 # 1890 # -- JOIN-Anweisung übernehmen ------------------------------------------ 1891 # 1892 liste.append( sqlJOIN ) 1893 1894 1895 # 1896 # -- WHERE-Anweisung übernehmen ------------------------------------------ 1897 # 1898 liste.append( sqlWHERE ) 1899 1900 1901 # 1902 # -- Liste zurückgeben -------------------------------------------------- 1903 # 1904 return liste

1905 1906 1907 1908 # 1909 # ------------------------------------------------------------------------------------ 1910 # -- -------------------------- 1911 # -- Liste der Tabellenwerte für >gibSQLSelect()< -------------------------- 1912 # -- -------------------------- 1913 # -- -> prj.zeige__prtprotokolltabellen -------------------------- 1914 # -- prt__protokoll__id -------------------------- 1915 # -- prj__p_prtstrstrkt__id -------------------------- 1916 # -- prj__p_prtstrstrkt__notizen -------------------------- 1917 # -- prj__p_prtstrstrkt__prj_projekte_id -------------------------- 1918 # -- prj__p_prtstrstrkt__str_strkt_id -------------------------- 1919 # -- -------------------------- 1920 # ------------------------------------------------------------------------------------ 1921 #

1922 - def gibSQLSelect__PrtProtokolltabellenStrStrkt( self, sqlJOIN = None, sqlWHERE = None ):

1923 """ 1924 Methode, die die Liste der Tabellenwerte für C{prj.zeige__prtprotokolltabellen -> Strukturpunkte} zurückgibt, die in C{gibSQLSelect(... , tabellen )} verwendet werden kann. 1925 1926 @param sqlJOIN: Es kann eine JOIN-Anweisung angegeben werden. Darf auch C{None} sein. 1927 @type sqlJOIN: Zeichenkette 1928 1929 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 1930 @type sqlWHERE: Zeichenkette 1931 1932 @return: Es wird die Python-Liste für C{gibSQLSelect(... , tebellen )} zurückgegeben. 1933 @rtype: Python-Liste 1934 """ 1935 1936 # 1937 # -- Der (die) Tabellenname(n) werden immer zurückgegeben ------------------ 1938 # 1939 liste = [] 1940 liste.append( "prj.zeige__prtprotokolltabellen" ) 1941 1942 1943 # 1944 # -- Der Spaltenname der Projekt-Identifikationsnummer wird immer ---------- 1945 # -- zurückgegeben ---------- 1946 # 1947 liste.append( "prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__prj_projekte_id" ) 1948 1949 1950 # 1951 # -- Die Vebindung zwischen beiden Tabellen zurückgegeben ------------------ 1952 # 1953 liste.append( None ) 1954 1955 1956 # 1957 # -- JOIN-Anweisung übernehmen ------------------------------------------ 1958 # 1959 liste.append( sqlJOIN ) 1960 1961 1962 # 1963 # -- WHERE-Anweisung übernehmen ------------------------------------------ 1964 # 1965 liste.append( sqlWHERE ) 1966 1967 1968 # 1969 # -- Liste zurückgeben -------------------------------------------------- 1970 # 1971 return liste

1972 1973 1974 1975 # 1976 # ------------------------------------------------------------------------------------ 1977 # -- -------------------------- 1978 # -- Liste der Tabellenwerte für >gibSQLSelect()< -------------------------- 1979 # -- -------------------------- 1980 # -- -> prj.zeige__strstrkt -------------------------- 1981 # -- -------------------------- 1982 # ------------------------------------------------------------------------------------ 1983 #

1984 - def gibSQLSelect__StrStrkt( self, sqlJOIN = None, sqlWHERE = None ):

1985 """ 1986 Methode, die die Liste der Tabellenwerte für C{prj.zeige__strstrkt} zurückgibt, die in C{gibSQLSelect(... , tabellen )} verwendet werden kann. 1987 1988 @param sqlJOIN: Es kann eine JOIN-Anweisung angegeben werden. Darf auch C{None} sein. 1989 @type sqlJOIN: Zeichenkette 1990 1991 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 1992 @type sqlWHERE: Zeichenkette 1993 1994 @return: Es wird die Python-Liste für C{gibSQLSelect(... , tebellen )} zurückgegeben. 1995 @rtype: Python-Liste 1996 """ 1997 1998 # 1999 # -- Der (die) Tabellenname(n) werden immer zurückgegeben ------------------ 2000 # 2001 liste = [] 2002 liste.append( "prj.zeige__strstrkt" ) 2003 2004 2005 # 2006 # -- Der Spaltenname der Projekt-Identifikationsnummer wird immer ---------- 2007 # -- zurückgegeben ---------- 2008 # 2009 liste.append( "prj.zeige__strstrkt.prj_projekte_id" ) 2010 2011 2012 # 2013 # -- Die Vebindung zwischen beiden Tabellen zurückgegeben ------------------ 2014 # 2015 liste.append( None ) 2016 2017 2018 # 2019 # -- JOIN-Anweisung übernehmen ------------------------------------------ 2020 # 2021 liste.append( sqlJOIN ) 2022 2023 2024 # 2025 # -- WHERE-Anweisung übernehmen ------------------------------------------ 2026 # 2027 liste.append( sqlWHERE ) 2028 2029 2030 # 2031 # -- Liste zurückgeben -------------------------------------------------- 2032 # 2033 return liste

2034 2035 2036 2037 # 2038 # ------------------------------------------------------------------------------------ 2039 # -- wxComboBox der Tabelle 'prj.projekte' initialisieren ------------------ 2040 # ------------------------------------------------------------------------------------ 2041 #

2042 - def init_internFirma( self, wxComboBox ):

2043 """ 2044 Methode zur Initialisierung der Auswahlliste (C{wxComboBox}), die die in der Datenbank verfügbaren Firmen aufnimmt (darstellt). 2045 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2046 2047 @note: Die übergebene Auswahlliste (C{wxComboBox}) wird verändert ! 2048 2049 @param wxComboBox: Es ist die Auswahlliste zu übergeben, die die Firmen aufnimmt. 2050 @type wxComboBox: wxPython - ComboBox 2051 """ 2052 2053 # 2054 # -- SQL-Abfrage ausführen -------------------------------------------------- 2055 # 2056 self.__dbAbfrage__( """ 2057 SELECT 2058 intern.gib__sqlSELECT( 'name 2059 , id' 2060 , ARRAY['intern.firma'] 2061 , ' AND id > 0' )""" ) 2062 2063 self.__initWxControlWithItems__( str( self.__gibWert__( 0, 0 ) ) 2064 , [u"-- Alle Firmen --", [0]] 2065 , wxComboBox ) 2066 2067 wxComboBox.SetSelection( 0 )

2068 2069 2070 2071 2072 # 2073 # ------------------------------------------------------------------------------------ 2074 # -- wxListBox der Tabelle 'prj.personen' initialisieren ------------------ 2075 # ------------------------------------------------------------------------------------ 2076 #

2077 - def init_prjPersonen( self, wxListBox ):

2078 """ 2079 Methode zur Initialisierung der Auswahlliste (C{wxListBox}), die die in der Datenbank verfügbaren Personen aufnimmt (darstellt). 2080 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2081 2082 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 2083 2084 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Personen aufnimmt. 2085 @type wxListBox: wxPython - ComboBox 2086 """ 2087 2088 # 2089 # gültige SQL-Abfrage erzeugen, 2090 # die gelesenen Werte der ComboBox zuordnen und 2091 # den ersten Eintrag auswählen 2092 # 2093 self.__dbAbfrage__( """ 2094 SELECT 2095 intern.gib__sqlSELECT( 'name_n || '', '' || name_v, id' 2096 , ARRAY['prj.personen'] 2097 , 'AND id > 0 2098 ORDER BY 2099 name_n 2100 , name_v' )""" ) 2101 2102 self.__initWxControlWithItems__( str( self.__gibWert__( 0, 0 ) ), [], wxListBox )

2103 2104 2105 2106 2107 # 2108 # ------------------------------------------------------------------------------------ 2109 # -- wxComboBox der Tabelle 'prj.projekte' initialisieren ------------------ 2110 # ------------------------------------------------------------------------------------ 2111 #

2112 - def init_prjProjekte( self, wxComboBox ):

2113 """ 2114 Methode zur Initialisierung der Auswahlliste (C{wxComboBox}), welche die in der Datenbank verfügbaren Projekte aufnimmt (darstellt). 2115 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2116 Es ist momentan nicht sinnvoll, die projektübergreifend gültigen Werte anzuzeigen. 2117 2118 @note: Die übergebene Auswahlliste (C{wxComboBox}) wird verändert ! 2119 2120 @param wxComboBox: Es ist die Auswahlliste zu übergeben, die die Projekte aufnimmt. 2121 @type wxComboBox: wxPython - ComboBox 2122 """ 2123 # 2124 # gültige SQL-Abfrage erzeugen, 2125 # die gelesenen Werte der ComboBox zuordnen und 2126 # den ersten Eintrag auswählen 2127 # 2128 self.__dbAbfrage__( """ 2129 SELECT 2130 intern.gib__sqlSELECT( 'prjname 2131 , id' 2132 , ARRAY['prj.projekte'] 2133 , 'AND id > 0 AND prjname NOT LIKE ''DBDokumentation''' )""" ) 2134 2135 self.__initWxControlWithItems__( str( self.__gibWert__( 0, 0 ) ) 2136 # Es ist momentan nicht sinnvoll, die projektübergreifend 2137 # gültigen Werte anzuzeigen. 2138 # , [u"-- projektübergreifend --", [0]] 2139 , [] 2140 , wxComboBox ) 2141 2142 wxComboBox.SetSelection( 0 )

2143 2144 2145 2146 # 2147 # ------------------------------------------------------------------------------------ 2148 # -- wxControlWithItems der Tabelle 'prt.typ' initialisieren ------------------ 2149 # ------------------------------------------------------------------------------------ 2150 #

2151 - def init_prtTyp( self, wxControlWithItems, sprSprachenId, prtTypAspekt, hatAlle = False ):

2152 """ 2153 Methode zur Initialisierung der Auswahlliste (C{wxControlWithItems}), welche die in der Datenbank verfügbaren Typen der Protokolleinträge / Sicherheitsanforderungen / Terminplaneinträge darstellt. 2154 Die Typen werden in Abhängigkeit vom aktuell übergebenen Aspekt (Protokolleintrag, Sicherheitsanforderung, Terminplaneintrag) ausgelesen. 2155 Sie werden nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2156 2157 @note: Die übergebene Auswahlliste (C{wxControlWithItems}) wird verändert ! 2158 2159 @param wxControlWithItems: Es ist die Auswahlliste zu übergeben, die die Wertepaare aufnimmt. 2160 @type wxControlWithItems: wxPython - wxControlWithItems 2161 2162 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 2163 @type sprSprachenId: Ganzzahl 2164 2165 @param prtTypAspekt: Es ist der Aspekt (Protokolleintrag, Sicherheitsanforderung, Terminplaneintrag) anzugeben. 2166 @type prtTypAspekt: Zeichenkette 2167 2168 @param hatAlle: Es ist C{True} anzugeben, wenn der Eintrag C{-- Alle Typen der Sicherheitsanforderungen --} hinzugefügt werden soll 2169 @type hatAlle: Booean 2170 """ 2171 2172 # 2173 # SQL-Abfrage ausführen, 2174 # die gelesenen Werte der ListBox zuordnen 2175 # 2176 alleTxt = [] 2177 if( hatAlle ) : alleTxt = [u"-- Alle Typen der Sicherheitsanforderungen --", [0]] 2178 2179 self.__initWxControlWithItems__( """ 2180 SELECT DISTINCT 2181 COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS typ 2182 , prt.typ.id 2183 FROM 2184 prt.typ LEFT OUTER JOIN spr.zeige__wgruppe ON ( 2185 prt.typ.spr_uebvar_id = spr.zeige__wgruppe.spr_uebvar_id 2186 AND 2187 -- Sprache Auswählen 2188 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ ) 2189 WHERE 2190 -- Aspekt des Typs auswählen 2191 prt.typ.aspekt = '""" + prtTypAspekt + """' 2192 ;""" 2193 , alleTxt 2194 , wxControlWithItems ) 2195 2196 wxControlWithItems.SetSelection( 0 )

2197 2198 2199 2200 # 2201 # ------------------------------------------------------------------------------------ 2202 # -- wxControlWithItems der Tabelle 'ps.abk' initialisieren ------------------ 2203 # ------------------------------------------------------------------------------------ 2204 #

2205 - def init_psAbk( self, LBGefPersonen, CBHaeufig, CBGefStufe, TCASRisikoStufe, prjProjekteId, sprSprachenId ):

2206 """ 2207 Methode zur Initialisierung der Auswahllisten 'Gefährdete Personen', 'Häufigkeit' und 'Gefahrenstufe'. 2208 Die Wertepaare werden in Abhängigkeit vom aktuell übergebenen Typ, Projekt und der aktuell übergebenen Sprache ausgelesen. 2209 Sie werden nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2210 2211 @note: Die übergebenen Auswahllisten werden verändert ! 2212 2213 @param LBGefPersonen: Es ist die Auswahlliste zu übergeben, die die gefährdeten Personen aufnimmt. 2214 @type LBGefPersonen: wxPython - wxListBox 2215 @param CBHaeufig: Es ist die Auswahlliste zu übergeben, die die Häufigkeit aufnimmt. 2216 @type CBHaeufig: wxPython - wxComboBox 2217 @param CBGefStufe: Es ist die Auswahlliste zu übergeben, die die Gefahrenstufe aufnimmt. 2218 @type CBGefStufe: wxPython - wxComboBox 2219 @param TCASRisikoStufe: Es ist die Auswahlliste zu übergeben, die die Risikostufen aufnimmt. 2220 @type TCASRisikoStufe: TextCtrlAuswStatisch 2221 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 2222 @type prjProjekteId: Ganzzahl 2223 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 2224 @type sprSprachenId: Ganzzahl 2225 """ 2226 2227 2228 # 2229 # SQL-Abfrage ausführen, 2230 # die gelesenen Werte der ListBox zuordnen 2231 # 2232 self.__dbAbfrage__( """ 2233 SELECT DISTINCT 2234 -- 0 2235 COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS abkuerzung 2236 , prj.zeige__psabk.ps__abk__id 2237 -- 2 2238 , prj.zeige__psabk.ps__abk__typ 2239 FROM 2240 prj.zeige__psabk LEFT OUTER JOIN spr.zeige__wgruppe ON ( 2241 prj.zeige__psabk.prj__p_psabk__spr_uebvar_id = spr.zeige__wgruppe.spr_uebvar_id 2242 AND 2243 -- 2244 -- Sprache Auswählen 2245 -- 2246 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ ) 2247 WHERE 2248 -- 2249 -- nur die gültigen Abkürzungen zeigen 2250 -- 2251 prj.zeige__psabk.ps__abk__id > 0 2252 AND 2253 -- 2254 -- Projekt auswählen 2255 -- 2256 prj.zeige__psabk.prj__p_psabk__prj_projekte_id = """ + str( prjProjekteId ) + """ 2257 ;""" ) 2258 2259 2260 # 2261 # -- >LBGefPersonen<, >CBHaeufig<, >CBGefStufe<, >TCASRisikoStufe< ---------- 2262 # -- löschen ---------- 2263 # 2264 clientData = [0] 2265 2266 LBGefPersonen.loescheAlles() 2267 2268 CBHaeufig.loescheAlles() 2269 CBHaeufig.Append( "---", clientData ) 2270 2271 CBGefStufe.loescheAlles() 2272 CBGefStufe.Append( "---", clientData ) 2273 2274 TCASRisikoStufe.loescheAlles() 2275 TCASRisikoStufe.nimmWert( wert = "---", clientData = clientData ) 2276 2277 2278 2279 # 2280 # -- Abkürzungen eintragen ---------------------------------- 2281 # 2282 # GP ... gefährdete Personen 2283 # RH ... Risikobewertung Häufigkeit 2284 # RG ... Risikobewertung Gefahrenstufe 2285 # RR ... Risikobewertung Risikostufe 2286 # 2287 for i in range( self.__gibAnzZeilen__() ): 2288 typ = self.__gibWert__( i, 2 ) 2289 clientData = [] 2290 2291 # 2292 # -- gefährdete Personen ------------------------------------------ 2293 # 2294 if typ == 'GP': 2295 clientData.append( self.__gibWert__( i, 1 ) ) 2296 LBGefPersonen.nimmWert( wert = self.__gibWert__( i, 0 ), clientData = clientData ) 2297 continue 2298 2299 # 2300 # -- Risikobewertung Häufigkeit ---------------------------------- 2301 # 2302 if typ == 'RH': 2303 clientData.append( self.__gibWert__( i, 1 ) ) 2304 CBHaeufig.nimmWert( wert = self.__gibWert__( i, 0 ), clientData = clientData ) 2305 continue 2306 2307 # 2308 # -- Risikobewertung Gefahrenstufe ---------------------------------- 2309 # 2310 if typ == 'RG': 2311 clientData.append( self.__gibWert__( i, 1 ) ) 2312 CBGefStufe.nimmWert( wert = self.__gibWert__( i, 0 ), clientData = clientData ) 2313 continue 2314 2315 # 2316 # -- Risikobewertung Risikostufe ---------------------------------- 2317 # 2318 if typ == 'RR': 2319 clientData.append( self.__gibWert__( i, 1 ) ) 2320 TCASRisikoStufe.nimmWert( wert = self.__gibWert__( i, 0 ) 2321 , clientData = clientData ) 2322 continue

2323 2324 2325 2326 2327 # 2328 # ------------------------------------------------------------------------------------ 2329 # -- wxListBox der Tabelle 'ps.gefszenario' initialisieren ------------------ 2330 # ------------------------------------------------------------------------------------ 2331 #

2332 - def init_psGefszenario( self, wxListBox, prjProjekteId ):

2333 """ 2334 Methode zur Initialisierung der Auswahlliste (C{wxListBox}), die die Gefahrenszenario-Id gültig im aktuell übergebenen Projekt aufnimmt (darstellt). 2335 2336 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 2337 2338 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Gefahrenszenario-Id aufnimmt. 2339 @type wxListBox: wxPython - ListBox 2340 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 2341 @type prjProjekteId: Ganzzahl 2342 """ 2343 2344 # 2345 # SQL-Abfrage ausführen, 2346 # die gelesenen Werte der ListBox zuordnen 2347 # 2348 self.__initWxControlWithItems__( """ 2349 SELECT DISTINCT 2350 prj.zeige__pp_psgefszenario.ps_gefszenario_id 2351 FROM 2352 prj.zeige__pp_psgefszenario 2353 WHERE 2354 -- 2355 -- Projekt auswählen 2356 -- 2357 prj.zeige__pp_psgefszenario.prj_projekte_id = """ + str( prjProjekteId ) + """ 2358 AND 2359 -- 2360 -- gültige Datensätze anzeigen 2361 -- 2362 prj.zeige__pp_psgefszenario.ps_gefszenario_id > 0 2363 ORDER BY 2364 prj.zeige__pp_psgefszenario.ps_gefszenario_id 2365 ;""" 2366 , [] 2367 , wxListBox ) 2368 2369 wxListBox.SetSelection( 0 )

2370 2371 2372 2373 2374 # 2375 # ------------------------------------------------------------------------------------ 2376 # -- wxComboBox der Tabelle 'spr.sprachen' initialisieren ------------------ 2377 # ------------------------------------------------------------------------------------ 2378 #

2379 - def init_sprSprachen( self, wxComboBox ):

2380 """ 2381 Methode zur Initialisierung der Auswahlliste (C{wxComboBox}), welche die in der Datenbank verfügbaren Sprachen aufnimmt (darstellt). 2382 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2383 2384 @note: Die übergebene Auswahlliste (C{wxComboBox}) wird verändert ! 2385 2386 @param wxComboBox: Es ist die Auswahlliste zu übergeben, die die Sprachen aufnimmt. 2387 @type wxComboBox: wxPython - ComboBox 2388 """ 2389 # 2390 # gültige SQL-Abfrage erzeugen, 2391 # die gelesenen Werte der ComboBox zuordnen und 2392 # den ersten Eintrag auswählen 2393 # 2394 self.__dbAbfrage__( """ 2395 SELECT 2396 intern.gib__sqlSELECT( 'sprache 2397 , id' 2398 , ARRAY['spr.sprachen'] 2399 , 'AND id > 0' )""" ) 2400 2401 self.__initWxControlWithItems__( str( self.__gibWert__( 0, 0 ) ), [], wxComboBox ) 2402 2403 wxComboBox.SetSelection( 0 )

2404 2405 2406 2407 2408 # 2409 # ------------------------------------------------------------------------------------ 2410 # -- wxComboBox der Tabelle 'spr.sprachen' initialisieren ------------------ 2411 # ------------------------------------------------------------------------------------ 2412 #

2413 - def init_sprWgruppe( self, wxListBox, sprUebvarId ):

2414 """ 2415 Methode zur Initialisierung der Auswahlliste (C{wxListBox}), welche die in der Datenbank verfügbaren Übersetzungen zur gegebenenen Übersetzungsvariante C{sprUebvarId} aufnimmt (darstellt). 2416 2417 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 2418 2419 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Strukturpunkte aufnimmt. 2420 @type wxListBox: wxPython - ListBox 2421 2422 @param sprUebvarId : Es ist die Id der Übersetzungsvariante C{spr.uebvar.id} zu übergeben. 2423 @type sprUebvarId : C{Ganzzahl} 2424 """ 2425 # 2426 # gültige SQL-Abfrage erzeugen, 2427 # die gelesenen Werte der ComboBox zuordnen und 2428 # den ersten Eintrag auswählen 2429 # 2430 2431 self.__initWxControlWithItems__( """ 2432 SELECT DISTINCT 2433 spr.zeige__wgruppe.wgruppe 2434 , spr_sprachen_id 2435 FROM 2436 spr.zeige__wgruppe 2437 WHERE 2438 spr.zeige__wgruppe.spr_uebvar_id = """ + str( sprUebvarId ) + """;""" 2439 , [] 2440 , wxListBox )

2441 2442 2443 2444 2445 # 2446 # ------------------------------------------------------------------------------------ 2447 # -- wxComboBox der Tabelle 'str.name' initialisieren ------------------ 2448 # ------------------------------------------------------------------------------------ 2449 #

2450 - def init_strName( self, wxComboBox ):

2451 """ 2452 Methode zur Initialisierung der Auswahlliste (C{wxComboBox}), welche die in der Datenbank verfügbaren Strukturnamen aufnimmt (darstellt). 2453 Sie werden nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2454 2455 @note: Die übergebene Auswahlliste (C{wxComboBox}) wird verändert ! 2456 2457 @param wxComboBox: Es ist die Auswahlliste zu übergeben, die die Strukturnamen aufnimmt. 2458 @type wxComboBox: wxPython - ComboBox 2459 """ 2460 # 2461 # gültige SQL-Abfrage erzeugen, 2462 # die gelesenen Werte der ComboBox zuordnen und 2463 # den ersten Eintrag auswählen 2464 # 2465 self.__dbAbfrage__( """ 2466 SELECT 2467 intern.gib__sqlSELECT( 'name 2468 , id' 2469 , ARRAY['str.name'] 2470 , 'AND id > 0' )""" ) 2471 2472 self.__initWxControlWithItems__( str( self.__gibWert__( 0, 0 ) ), [], wxComboBox ) 2473 2474 wxComboBox.SetSelection( 0 )

2475 2476 2477 2478 2479 # 2480 # ------------------------------------------------------------------------------------ 2481 # -- wxListBox der Tabelle 'str.name' initialisieren ------------------ 2482 # ------------------------------------------------------------------------------------ 2483 #

2484 - def init_strName( self, wxComboBox ):

2485 """ 2486 Methode zur Initialisierung der Auswahlliste (C{wxComboBox}), die die in der Datenbank verfügbaren Strukturbezeichnungen aufnimmt (darstellt). 2487 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2488 2489 @note: Die übergebene Auswahlliste (C{wxComboBox}) wird verändert ! 2490 2491 @param wxComboBox: Es ist die Auswahlliste zu übergeben, die die Strukturbezeichnungen aufnimmt. 2492 @type wxComboBox: wxPython - ComboBox 2493 """ 2494 2495 # 2496 # -- SQL-Abfrage ausführen -------------------------------------------------- 2497 # 2498 self.__dbAbfrage__( """ 2499 SELECT 2500 intern.gib__sqlSELECT( 'name_k || '' | '' || name 2501 , id' 2502 , ARRAY['str.name'] 2503 , ' AND id > 0 AND id <> 2' )""" ) 2504 2505 self.__initWxControlWithItems__( str( self.__gibWert__( 0, 0 ) ) 2506 , [u"-- Alle Strukturen --", [0]] 2507 , wxComboBox ) 2508 2509 wxComboBox.SetSelection( 0 )

2510 2511 2512 2513 2514 # 2515 # ------------------------------------------------------------------------------------ 2516 # -- wxListBox der Tabelle 'str.strkt' initialisieren ------------------ 2517 # ------------------------------------------------------------------------------------ 2518 #

2519 - def init_strStrkt( self, wxListBox, prjProjekteId, sprSprachenId, strNameId ):

2520 """ 2521 Methode zur Initialisierung der Auswahlliste (C{wxListBox}), welche die Strukturpunkte gültig im aktuell übergebenen Projekt, dargestellt in der aktuell übergebenen Sprache zur aktuell übergebenen Struktur aufnimmt (darstellt). 2522 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 2523 2524 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 2525 2526 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Strukturpunkte aufnimmt. 2527 @type wxListBox: wxPython - ListBox 2528 2529 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 2530 @type prjProjekteId: Ganzzahl 2531 2532 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 2533 @type sprSprachenId: Ganzzahl 2534 2535 @param strNameId: Es ist die Datenbankidentifikationsnummer (C{str.name.id}) der Strukturbezeichnung zu übergeben. 2536 @type strNameId: Ganzzahl 2537 """ 2538 2539 # 2540 # SQL-Abfrage ausführen, 2541 # die gelesenen Werte der ListBox zuordnen 2542 # 2543 self.__initWxControlWithItems__( """ 2544 SELECT DISTINCT 2545 str__strkt__nr || ' ' 2546 || COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS strukturpunkt 2547 , str__strkt__id 2548 FROM 2549 prj.zeige__strstrkt LEFT OUTER JOIN spr.zeige__wgruppe ON ( 2550 prj.zeige__strstrkt.prj__pp_strstrkt__spr_uebvar_id = spr.zeige__wgruppe.spr_uebvar_id 2551 AND 2552 -- 2553 -- Sprache Auswählen 2554 -- 2555 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ ) 2556 WHERE 2557 -- 2558 -- Strukturnamen auswählen 2559 -- 2560 str__name__id = """ + str( strNameId ) + """ 2561 AND 2562 -- 2563 -- Projekt auswählen 2564 -- 2565 prj_projekte_id = """ + str( prjProjekteId ) + """ 2566 ORDER BY 2567 str__strkt__id 2568 ;""" 2569 , [] 2570 , wxListBox )

2571 2572 2573 2574 2575 # 2576 # ------------------------------------------------------------------------------------ 2577 # -- ------------------ 2578 # ------------------------------------------------------------------------------------ 2579 #

2580 - def istIdMehrfachVerwendet( self, zielSpalte, dbId ):

2581 """ 2582 Es wird C{True} zurückgegeben, wenn der Wert C{dbId}, der in C{zielSpalte} enthalten ist, in mindestens zwei Tabellen der Datenbank verwendet (referenziert) wird. 2583 2584 @param zielSpalte: Es ist der vollständige Datenbankspaltenname anzugeben, auf den mittels Fremdschlüssel verwiesen wird. 2585 @type zielSpalte: Zeichenkette 2586 2587 @param dbId: Es ist die Datenbankidentifikationsnummer anzugeben, die überprüft werden soll. 2588 @type dbId: Ganzzahl 2589 2590 @return: Es wird C{True} zurückgegeben, wenn C{dbId} in mindestens zwei Tabellen verwendet wird. 2591 @rtype: Ganzzahl 2592 """ 2593 2594 # 2595 # -- Liste der Tabellenverbindungen auswählen -------------------------- 2596 # 2597 liste = None 2598 2599 if( zielSpalte == 'spr.uebvar.id' ) : liste = self.listeTabellenSprUebvarId 2600 2601 if( liste is None ) : return False 2602 2603 2604 # 2605 # -- alle Tabellen durchlaufen, die auf >zielSpalte< referenzieren ---------- 2606 # 2607 anzVerwendet = 0 2608 for i in range( len( liste ) ) : 2609 2610 self.__dbAbfrage__( """ 2611 -- 2612 -- Anzahl der Zeilen in der akt. Tabelle zählen, die >dbId< verwenden 2613 -- 2614 SELECT 2615 count( """ + liste[i][1] + """ ) 2616 FROM 2617 """ + liste[i][0] + """ 2618 WHERE 2619 idfrei = 0 2620 AND 2621 """ + liste[i][1] + """ = """ + str( dbId ) + """ 2622 ;""" ) 2623 2624 anzVerwendet += self.__gibWert__( 0, 0 ) 2625 2626 if( anzVerwendet > 1 ) : return True 2627 2628 2629 2630 # 2631 # -- >dbId< wurde nicht mehrfach verwendet ---------------------------------- 2632 # 2633 return False

2634 2635 2636 2637 # 2638 # ------------------------------------------------------------------------------------ 2639 # -- Änderungen übernehmen (aktuelle Transaktion schließen, ------------------ 2640 # -- neue Transaktion starten) ------------------ 2641 # ------------------------------------------------------------------------------------ 2642 #

2643 - def nimmAenderungen( self ):

2644 """ 2645 Es werden alle Änderungen in die Datenbank geschrieben, die laufende Transaktion beendet und eine neue Transaktion gestartet. 2646 """ 2647 2648 # 2649 # -- Änderungen übernehmen, Transaktion starten -------------------------- 2650 # 2651 self.dbVerbindung.commit()

2652 2653 2654 2655 2656 2657 # 2658 # ------------------------------------------------------------------------------------ 2659 # -- Alle Änderungen seit Setzen eines PostgreSQL-Safepoints übernehmen -- 2660 # ------------------------------------------------------------------------------------ 2661 #

2662 - def nimmAenderungenSafepoint( self, name ):

2663 """ 2664 Methode zum Übernehmen der Änderungen, welche seit dem Setzen eines C{PostgreSQL - Safepoints} durchgeführt wurden. Mittels C{Safepoint} können Teile einer Transaktion gespeichert oder verworfen werden. 2665 2666 @param name: Es ist der Name des C{Safepoints} anzugeben. 2667 @type name: Zeichenkette 2668 """ 2669 2670 # 2671 # -- Änderungen übernehmen -------------------------------------------------- 2672 # 2673 self.__dbAbfrage__( 'RELEASE SAVEPOINT ' + name + ';' )

2674 2675 2676 2677 2678 2679 # 2680 # ------------------------------------------------------------------------------------ 2681 # -- Schreibe Tabellen: ---------- 2682 # -- >prj.ppl_dokdoku<, >prj.pl_prtdokdoku<, >prj.pl_dokausgabe< ---------- 2683 # ------------------------------------------------------------------------------------ 2684 #

2685 - def schreibe__Dokumente( self, TreeCtrlErg, prjProjekteId, sprSprachenId, nimmAusgabe = False, psGefszenarioId = None ):

2686 """ 2687 Übernehmen der Strukturpunkte, die den im C{TreeCtrlErg} selektierten Sicherheitsanforderungen C{prt.protokoll.id} zugeordnet sind, in das Projekt C{prjProjekteId}. 2688 2689 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die selektierten Sicherheitsanforderungen enthält. 2690 @type TreeCtrlErg: TreeCtrlErg 2691 2692 @param prjProjekteId : Es ist die Projekt-Id C{prj.projekte.id} zu übergeben. 2693 @type prjProjekteId : C{Ganzzahl} 2694 2695 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 2696 @type sprSprachenId: Ganzzahl 2697 2698 @param nimmAusgabe: Es ist C{True} anzugeben, wenn die Ausgabe zum Dokument übernommen werden soll. 2699 @type nimmAusgabe: Boolean 2700 2701 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben, wenn die Dokumente von der Sicherheitsanforderung gelöst werden sollen. Sonst ist C{None} anzugeben. 2702 @type psGefszenarioId: Ganzzahl 2703 """ 2704 2705 # 2706 # -- alle Sicherheitsanforderungen-Id zusammenstellen -------------------------- 2707 # 2708 eintragListe = TreeCtrlErg.gibZweig( eintrag = TreeCtrlErg.GetSelection() ) 2709 prtProtokollIdListe = "" 2710 2711 for i in range( len( eintragListe ) ) : 2712 2713 if( i > 0 ) : prtProtokollIdListe = prtProtokollIdListe + ', ' 2714 prtProtokollIdListe = prtProtokollIdListe + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) 2715 2716 2717 # 2718 # -- Wenn Dokument von der Sicherheitsanforderung gelöst wird: ---------- 2719 # -- Sicherheitsanforderungen in Liste der nichtzutrennenden ---------- 2720 # -- SiAnf-Id aufnehmen ---------- 2721 # 2722 logentfernt = False 2723 nichtTrennen = [] 2724 2725 if( psGefszenarioId is not None ) : 2726 2727 logentfernt = True 2728 2729 self.__dbAbfrage__( self.gibSQLSelect( 2730 select = """ 2731 SELECT DISTINCT 2732 prt_protokoll_id""" 2733 , tabellen = [ self.gibSQLSelect__PlPrtPsGefszenario( sqlJOIN = None 2734 , sqlWHERE = """ 2735 AND 2736 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id IN( """ + str( prtProtokollIdListe ) + """ ) 2737 AND 2738 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id != """ + str( psGefszenarioId ) + """ 2739 AND 2740 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ + str( prjProjekteId ) ) ] ) ) 2741 2742 for i in range( self.__gibAnzZeilen__() ): 2743 2744 nichtTrennen.append( self.__gibWert__( i, 0 ) ) 2745 2746 2747 2748 # 2749 # -- zugeordnete Dokumente auslesen ------------------------------------------ 2750 # 2751 prjProjekteIdintern = None 2752 2753 if( logentfernt ) : prjProjekteIdintern = prjProjekteId 2754 2755 self.__dbAbfrage__( self.gibSQL_prjPrtDoku( prjProjekteId = prjProjekteIdintern 2756 , sprSprachenId = sprSprachenId 2757 , prtProtokollId = prtProtokollIdListe 2758 , psGefszenarioId = None 2759 , internFirmaId = None ) ) 2760 2761 2762 # 2763 # -- 2764 # -- >prj.pl_prtdokdoku< -------------------------------------------------- 2765 # -- 2766 # -- prj_projekte_id <- prjProjekteId ------------------ 2767 # -- logentfernt <- 'false' ------------------ 2768 # -- 2769 # -- dok_doku_id <- self.__gibWert__( i, 0 ) ------------------ 2770 # -- prt_protokoll_id <- self.__gibWert__( i, 13 ) ------------------ 2771 # -- 2772 # -- nr <- self.__gibWert__( i, 2 ) ------------------ 2773 # -- spr_uebvar_id <- self.__gibWert__( i, 10 ) ------------------ 2774 # -- spr_uebvar_id_zus <- self.__gibWert__( i, 11 ) ------------------ 2775 # -- notizen <- self.__gibWert__( i, 4 ) ------------------ 2776 # 2777 # -- 2778 # -- >prj.pl_dokausgabe< -------------------------------------------------- 2779 # -- 2780 # -- prj_projekte_id <- prjProjekteId ------------------ 2781 # -- logentfernt <- 'false' ------------------ 2782 # -- 2783 # -- dok_doku_id <- self.__gibWert__( i, 0 ) ------------------ 2784 # -- 2785 # -- stand <- self.__gibWert__( i, 5 ) ------------------ 2786 # -- datum <- self.__gibWert__( i, 6 ) ------------------ 2787 # -- istfrei <- self.__gibWert__( i, 12 ) ------------------ 2788 # -- notizen <- self.__gibWert__( i, 7 ) ------------------ 2789 # -- 2790 # 2791 werte = [] 2792 plPrtDokdoku = [] 2793 plDokAusgabe = [] 2794 for i in range( self.__gibAnzZeilen__() ): 2795 2796 werte.append( [ self.__gibWert__( i, 0 ) 2797 , self.__gibWert__( i, 13 ) ] ) 2798 2799 plPrtDokdoku.append( [ self.__gibWert__( i, 2 ) 2800 , self.__gibWert__( i, 10 ) 2801 , self.__gibWert__( i, 11 ) 2802 , self.__gibWert__( i, 4 ) ] ) 2803 2804 2805 if( not nimmAusgabe ) : continue 2806 2807 plDokAusgabe.append( [ self.__gibWert__( i, 5 ) 2808 , self.__gibWert__( i, 6 ) 2809 , self.__gibWert__( i, 12 ) 2810 , self.__gibWert__( i, 7 ) ] ) 2811 2812 2813 # 2814 # -- Dokumente übernehmen / trennen ------------------------------------------ 2815 # 2816 for i in range( len( werte ) ) : 2817 2818 if( werte[i][1] in nichtTrennen ) : continue 2819 2820 plDokAusgabeIntern = None 2821 2822 if( nimmAusgabe and len( plDokAusgabe[i][0] ) > 0 ) : plDokAusgabeIntern = plDokAusgabe[i] 2823 2824 self.schreibe__prjPrtDoku( prjProjekteId = prjProjekteId 2825 , prtProtokollId = werte[i][1] 2826 , dokDokuId = werte[i][0] 2827 , plPrtDokdoku = plPrtDokdoku[i] 2828 , plDokAusgabe = plDokAusgabeIntern 2829 , logentfernt = logentfernt )

2830 2831 2832 2833 2834 # 2835 # ------------------------------------------------------------------------------------ 2836 # -- In Tabelle >prj.pp_strstrkt< schreiben -------------------------- 2837 # ------------------------------------------------------------------------------------ 2838 #

2839 - def schreibe__PrjPpStrstrkt( self, prjProjekteId, strStrktId, prjPersonenId, sprUebvarId, fbereignis, notizen ):

2840 """ 2841 Methode zum Einfügen / Aktualisieren projektspezifischer Informationen in die / der Datenbanktabelle C{prj.pp_strstrkt}. 2842 2843 @param prjProjekteId : Es ist die Projekt-Id C{prj.projekte.id} zu übergeben. 2844 @type prjProjekteId : C{Ganzzahl} 2845 2846 @param strStrktId : Es ist die Struktur-Id C{str.strkt.id} zu übergeben. 2847 @type strStrktId : C{Ganzzahl} 2848 2849 @param prjPersonenId : Es ist die Personen-Id C{prj.personen.id} zu übergeben. 2850 @type prjPersonenId : C{Ganzzahl} 2851 2852 @param sprUebvarId : Es ist die Id der Übersetzungsvariante C{spr.uebvar.id} zu übergeben. 2853 @type sprUebvarId : C{Ganzzahl} 2854 2855 @param fbereignis : Es ist das Fehlerbaumereignis zu übergeben 2856 @type fbereignis : C{Zeichenkette} 2857 2858 @param notizen : Es sind die Notizen zu übergeben. 2859 @type notizen : C{Zeichenkette} 2860 """ 2861 2862 # 2863 # -- 2864 # -- Strukturpunkte in das Projekt übernehmen -------------------------- 2865 # -- >prj.pp_strstrkt< ---------- 2866 # -- ---------- 2867 # -- ---------- 2868 # -- prj.nimm__tabwerte( 'pp_strstrkt', ARRAY[ ---------- 2869 # -- 1. prj_projekte_id ---------- 2870 # -- 2. str_strkt_id ---------- 2871 # -- 3. prj_personen_id ---------- 2872 # -- 5. spr_uebvar_id ---------- 2873 # -- 6. fbereignis ---------- 2874 # -- 8. notizen ---------- 2875 # -- ---------- 2876 # -- ---------- 2877 # -- -------------------------------------------------------------------------- 2878 # 2879 self.__dbAbfrage__( """ 2880 SELECT prj.nimm__tabwerte( 'pp_strstrkt', ARRAY[""" 2881 # 2882 # -- prj_projekte_id ---------------------------------- 2883 # 2884 + "'" + str( prjProjekteId ) + "'" 2885 # 2886 # -- str_strkt_id ------------------------------------------ 2887 # 2888 + ", '" + str( strStrktId ) + "'" 2889 # 2890 # -- prj_personen_id ---------------------------------- 2891 # 2892 + ", '" + str( prjPersonenId ) + "'" 2893 # 2894 # -- spr_uebvar_id ------------------------------------------ 2895 # 2896 + ", '" + str( sprUebvarId ) + "']);" )

2897 # 2898 # -- fbereignis ------------------------------------------ 2899 # 2900 # + ", '" + fbereignis + "'" 2901 # 2902 # -- notizen ------------------------------------------ 2903 # 2904 # + ", '" + notizen + "']);" ) 2905 2906 2907 2908 2909 2910 # 2911 # ------------------------------------------------------------------------------------ 2912 # -- Schreibe Tabellen: ---------- 2913 # -- >prj.pp_strstrkt<, >prj.p_strverbindung<, >prj.p_prtstrstrkt< ---------- 2914 # ------------------------------------------------------------------------------------ 2915 #

2916 - def schreibe__Strukturpunkte( self, TreeCtrlErg, prjProjekteId, sprSprachenId, psGefszenarioId = None ):

2917 """ 2918 Übernehmen der Strukturpunkte, die den im C{TreeCtrlErg} selektierten Sicherheitsanforderungen C{prt.protokoll.id} zugeordnet sind, in das Projekt C{prjProjekteId}. 2919 2920 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die selektierten Sicherheitsanforderungen enthält. 2921 @type TreeCtrlErg: TreeCtrlErg 2922 2923 @param prjProjekteId : Es ist die Projekt-Id C{prj.projekte.id} zu übergeben. 2924 @type prjProjekteId : C{Ganzzahl} 2925 2926 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 2927 @type sprSprachenId: Ganzzahl 2928 2929 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben, wenn die Strukturpunkte von der Sicherheitsanforderung gelöst werden sollen. Sonst ist C{None} anzugeben. 2930 @type psGefszenarioId: Ganzzahl 2931 """ 2932 2933 # 2934 # -- Sicherheitsanforderung(en) entfernen ---------------------------------- 2935 # 2936 siAnfEntfernen = ( psGefszenarioId is not None ) 2937 2938 2939 2940 # 2941 # -- alle Sicherheitsanforderungen-Id zusammenstellen ------------------ 2942 # 2943 eintragListe = TreeCtrlErg.gibZweig( eintrag = TreeCtrlErg.GetSelection() ) 2944 prtProtokollIdListe = "" 2945 2946 for i in range( len( eintragListe ) ) : 2947 2948 if( i > 0 ) : prtProtokollIdListe = prtProtokollIdListe + ', ' 2949 prtProtokollIdListe = prtProtokollIdListe + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) 2950 2951 2952 2953 # 2954 # -- Sicherheitsanforderung(en) übernehmen: ---------- 2955 # -- ---------- 2956 # -- Die den Sicherheitsanforderungen-Id zugeordneten Strukturpunkte ---------- 2957 # -- projektübergreifend ermitteln ---------- 2958 # -- ---------- 2959 # -- ---------- 2960 # -- Sicherheitsanforderung(en) entfernen: ---------- 2961 # -- ---------- 2962 # -- Die Strukturpunkte kennzeichnen, die einem weiteren ---------- 2963 # -- Gefahrenszenario zugeordnet sind. ---------- 2964 # -- Diese Strukturpunkte dürfen nicht aus dem Projekt entfernt ---------- 2965 # -- werden. ---------- 2966 # -- ---------- 2967 # -- ---------- 2968 # -- ACHTUNG ! ---------- 2969 # -- ---------- 2970 # -- Strukturzuordnungen zu Dokumenten mittels >prj.p_dokstrkt< ---------- 2971 # -- werden momentan mißachtet ! ---------- 2972 # -- Strukturzuordnungen zu Gefahrenszenarien mittels ---------- 2973 # -- >prj.pl_psgefstrkt< werden implizit über ---------- 2974 # -- >prj.zeige__strstrkt.str__name__id != 2< berücksichtigt. ---------- 2975 # 2976 select = """ 2977 SELECT DISTINCT 2978 -- 0 2979 prj.zeige__strstrkt.str__strkt__id 2980 , nachfok.str__strkt__id AS str_strkt_id__vorg 2981 -- 2 2982 , prj.zeige__prtprotokolltabellen.prt__protokoll__id 2983 , prj.zeige__strstrkt.prj__pp_strstrkt__prj_personen_id 2984 -- 4 2985 , prj.zeige__strstrkt.prj__pp_strstrkt__spr_uebvar_id""" 2986 2987 tabellen = [ 2988 self.gibSQLSelect__StrStrkt( 2989 sqlJOIN = """ 2990 -- 2991 -- aktueller Strukturpunkt ist ein gültiger Nachfolger 2992 -- 2993 LEFT OUTER JOIN prj.zeige__strstrkt AS nachfok ON ( 2994 nachfok.prj__p_strverbindung__str_strkt_id_nachf = 2995 prj.zeige__strstrkt.str__strkt__id 2996 AND 2997 nachfok.prj_projekte_id = prj.zeige__strstrkt.prj_projekte_id 2998 )""" 2999 , sqlWHERE = """ 3000 -- 3001 -- -- Gefahrennetz nicht anzeigen ---------------------------------- 3002 -- 3003 prj.zeige__strstrkt.str__name__id != 2""" ) 3004 , self.gibSQLSelect__PrtProtokolltabellenStrStrkt( 3005 sqlJOIN = None 3006 , sqlWHERE = """ 3007 AND 3008 -- 3009 -- -- Strukturpunkt zuordnen ------------------------------------------ 3010 -- 3011 prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__str_strkt_id = 3012 prj.zeige__strstrkt.str__strkt__id""" ) ] 3013 3014 sqlWHERE = """ 3015 AND 3016 -- 3017 -- -- Protokoll auswählen / zuordnen ---------------------------------- 3018 -- 3019 prj.zeige__prtprotokolltabellen.prt__protokoll__id IN( """ + str( prtProtokollIdListe ) + """ )""" 3020 3021 prjProjekteIdintern = prjProjekteId 3022 3023 3024 3025 # 3026 # -- Sicherheitsanforderung(en) entfernen ---------------------------------- 3027 # 3028 if( siAnfEntfernen ) : 3029 3030 select = select + ( """ 3031 , ( ( prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id = """ 3032 + str( psGefszenarioId ) 3033 + """ AND prj.zeige__prtprotokolltabellen.prt__protokoll__id NOT IN( """ 3034 + str( prtProtokollIdListe ) 3035 + """ ) ) OR ( prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id != """ 3036 + str( psGefszenarioId ) 3037 + """ ) ) AS nicht_entfernen""" ) 3038 3039 tabellen.append( self.gibSQLSelect__PlPrtPsGefszenario( sqlJOIN = None 3040 , sqlWHERE = """ 3041 AND 3042 -- 3043 -- -- Protokollpunkt zuordnen ------------------------------------------ 3044 -- 3045 prj.zeige__prtprotokolltabellen.prt__protokoll__id = 3046 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id 3047 AND 3048 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ + str( prjProjekteId ) + """ 3049 ORDER BY 3050 nicht_entfernen""" ) ) 3051 3052 sqlWHERE = None 3053 3054 prjProjekteIdintern = 0 3055 3056 3057 3058 # 3059 # -- SQL-Abfrage ausführen -------------------------------------------------- 3060 # 3061 self.__dbAbfrage__( self.gibSQLSelect( select = select, tabellen = tabellen, sqlWHERE = sqlWHERE ) ) 3062 3063 3064 3065 # 3066 # -- str_strkt_id <- self.__gibWert__( i, 0 ) ------------------ 3067 # -- str_strkt_id_nachf <- self.__gibWert__( i, 0 ) ------------------ 3068 # -- str_strkt_id_vorg <- self.__gibWert__( i, 1 ) ------------------ 3069 # -- prt_protokoll_id <- self.__gibWert__( i, 2 ) ------------------ 3070 # -- prj_personen_id <- self.__gibWert__( i, 3 ) ------------------ 3071 # -- spr_uebvar_id <- self.__gibWert__( i, 4 ) ------------------ 3072 # -- ------------------ 3073 # -- nicht Entfernen <- self.__gibWert__( i, 5 ) ------------------ 3074 # 3075 werte = [] 3076 nichtEntfernen = [] 3077 3078 for i in range( self.__gibAnzZeilen__() ): 3079 3080 werte.append( [ self.__gibWert__( i, 0 ) 3081 , self.__gibWert__( i, 1 ) 3082 , self.__gibWert__( i, 2 ) 3083 , self.__gibWert__( i, 3 ) 3084 , self.__gibWert__( i, 4 ) ] ) 3085 3086 3087 # 3088 # -- Nur für Sicherheitsanforderung(en) entfernen: ---------- 3089 # -- ---------- 3090 # -- Alle hier eingetragenen Strukturpunkte werden in ---------- 3091 # -- weiteren Gefahrenszenarien bzw. weiteren Sicherheits- ---------- 3092 # -- anforderungen verwendet. ---------- 3093 # -- Sie durfen nicht aus dem Projekt entfernt werden ! ---------- 3094 # 3095 if( siAnfEntfernen and self.__gibWert__( i, 5 ) == True ) : 3096 3097 nichtEntfernen.append( werte[i][0] ) 3098 nichtEntfernen.append( werte[i][1] ) 3099 3100 3101 3102 # 3103 # -- Strukturpunkte ... ------------------------------------------ 3104 # 3105 for i in range( len( werte ) ) : 3106 3107 # 3108 # -- Nur für Sicherheitsanforderung(en) entfernen: ---------- 3109 # -- ---------- 3110 # -- Alle hier eingetragenen Strukturpunkte werden in ---------- 3111 # -- weiteren Gefahrenszenarien bzw. weiteren Sicherheits- ---------- 3112 # -- anforderungen verwendet. ---------- 3113 # -- Sie durfen nicht aus dem Projekt entfernt werden ! ---------- 3114 # 3115 if( werte[i][0] in nichtEntfernen ) : continue 3116 3117 3118 3119 # 3120 # -- 3121 # -- ... in das Projekt (auch Projekt '0') übernehmen ---------- 3122 # -- >prj.pp_strstrkt< ---------- 3123 # -- ---------- 3124 # 3125 self.schreibe__PrjPpStrstrkt( prjProjekteId = prjProjekteIdintern 3126 , strStrktId = werte[i][0] 3127 , prjPersonenId = werte[i][3] 3128 , sprUebvarId = werte[i][4] 3129 , fbereignis = "" 3130 , notizen = "" ) 3131 3132 # 3133 # -- Sicherheitsanforderung(en) entfernen: ------------------ 3134 # -- Strukturpunkte aus dem Projekt entfernen ------------------ 3135 # 3136 if( siAnfEntfernen ) : 3137 3138 self.__dbAbfrage__( """ 3139 SELECT intern.loesche__zeile( 'prj.pp_strstrkt' 3140 , 'prj_personen_id = """ + str( werte[i][3] ) + """ 3141 AND prj_projekte_id = """ + str( prjProjekteId ) + """ 3142 AND str_strkt_id = """ + str( werte[i][0] ) + """' 3143 , 'true');""" ) 3144 3145 3146 3147 # 3148 # -- ... miteinander verbinden, wenn Vorgänger existiert ---------- 3149 # -- >prj.p_strverbindung< ---------- 3150 # 3151 if( werte[i][1] != '' ): 3152 3153 self.schreibe__prjPStrverbindung( prjProjekteId = prjProjekteIdintern 3154 , strStrktIdVorg = werte[i][1] 3155 , strStrktIdNachf = werte[i][0] 3156 , fbtor = "" 3157 , notizen = "" ) 3158 3159 # 3160 # -- Sicherheitsanforderung(en) entfernen: ------------------ 3161 # -- Verbindung zwischen den Strukturpunkten aus ------------------ 3162 # -- dem Projekt entfernen ------------------ 3163 # 3164 if( siAnfEntfernen ) : 3165 3166 self.__dbAbfrage__( """ 3167 SELECT intern.loesche__zeile( 'prj.p_strverbindung' 3168 , 'prj_projekte_id = """ + str( prjProjekteId ) + """ 3169 AND str_strkt_id_nachf = """ + str( werte[i][0] ) + """ 3170 AND str_strkt_id_vorg = """ + str( werte[i][1] ) + """' 3171 , 'true');""" ) 3172 3173 3174 3175 # 3176 # -- ... mit den Protokolleinträgen verbinden ------------------ 3177 # -- >prj.p_prtstrstrkt< ------------------ 3178 # 3179 self.schreibe__psPrtStrkt( prjProjekteId = prjProjekteIdintern 3180 , prtProtokollId = werte[i][3] 3181 , strStrktId = werte[i][0] 3182 , notizen = '' ) 3183 3184 # 3185 # -- Sicherheitsanforderung(en) entfernen: ------------------ 3186 # -- Strukturpunkte von den Protokolleinträgen lösen ------------------ 3187 # 3188 if( siAnfEntfernen ) : 3189 3190 self.__dbAbfrage__( """ 3191 SELECT intern.loesche__zeile( 'prj.p_prtstrstrkt' 3192 , 'prj_projekte_id = """ + str( prjProjekteId ) + """ 3193 AND prt_protokoll_id = """ + str( werte[i][3] ) + """ 3194 AND str_strkt_id = """ + str( werte[i][0] ) + """' 3195 , 'true');""" )

3196 3197 3198 3199 3200 # 3201 # ------------------------------------------------------------------------------------ 3202 # -- Protokolleintrag und Dokument projektspezifisch verbinden ---------- 3203 # ------------------------------------------------------------------------------------ 3204 #

3205 - def schreibe__prjPrtDoku( self, prjProjekteId, prtProtokollId, dokDokuId, plPrtDokdoku, plDokAusgabe, logentfernt = 'false' ):

3206 """ 3207 Methode zum Herstellen der projektspezifischen Verbindung zwischen Protokolleintrag und Dokument. 3208 3209 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 3210 @type prjProjekteId: Ganzzahl 3211 3212 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 3213 @type prtProtokollId: Ganzzahl 3214 3215 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 3216 @type prtProtokollId: Ganzzahl 3217 3218 @param dokDokuId: Es ist die Datenbankidentifikationsnummer (C{dok.doku.id}) des aktuellen Dokumentes zu übergeben, welches dem Protokolleintrag zugeordnet werden soll. 3219 @type dokDokuId: Ganzzahl 3220 3221 @param plPrtDokdoku: Es sind die Detailwerte zum Dokument (C{dok.doku.id}) zu übergeben: C{nr, spr_uebvar_id, spr_uebvar_id_zus, notizen} 3222 @type plPrtDokdoku: Liste 3223 3224 @param plDokAusgabe: Es sind die Detailwerte zur aktuellen Ausgabe des Dokumentes (C{dok.doku.id}) zu übergeben: C{stand, datum, istfrei, notizen} 3225 @type plDokAusgabe: Liste 3226 3227 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 3228 @type logentfernt: Zeichenkette, die C{true/false} enthält 3229 """ 3230 3231 # 3232 # -- 3233 # -- Protokolleintrag und Dokument verbinden ---------------------------------- 3234 # -- >prj.pl_prtdokdoku< ---------- 3235 # -- ---------- 3236 # -- ---------- 3237 # -- prj.nimm__tabwerte( 'pl_prtdokdoku', ARRAY[ ---------- 3238 # -- 1. prj_projekte_id ---------- 3239 # -- 2. dok_doku_id ---------- 3240 # -- 3. prt_protokoll_id ---------- 3241 # -- 4. nr ---------- 3242 # -- 5. spr_uebvar_id ---------- 3243 # -- 6. logentfernt ---------- 3244 # -- 7. spr_uebvar_id_zus ---------- 3245 # -- 8. notizen ---------- 3246 # -- ---------- 3247 # -- ---------- 3248 # -- -------------------------------------------------------------------------- 3249 # 3250 self.__dbAbfrage__( """ 3251 SELECT prj.nimm__tabwerte( 'pl_prtdokdoku', ARRAY[""" 3252 # 3253 # -- prj_projekte_id ---------------------------------- 3254 # 3255 + "'" + str( prjProjekteId ) + "'" 3256 # 3257 # -- dok_doku_id ------------------------------------------ 3258 # 3259 + ", '" + str( dokDokuId ) + "'" 3260 # 3261 # -- prt_protokoll_id ---------------------------------- 3262 # 3263 + ", '" + str( prtProtokollId ) + "'" 3264 # 3265 # -- nr -------------------------------------------------- 3266 # 3267 + ", '" + str( plPrtDokdoku[0] ) + "'" 3268 # 3269 # -- spr_uebvar_id ------------------------------------------ 3270 # 3271 + ", '" + str( plPrtDokdoku[1] ) + "'" 3272 # 3273 # -- logentfernt ------------------------------------------ 3274 # 3275 + ", '" + str( logentfernt ) + "'" 3276 # 3277 # -- spr_uebvar_id_zus ---------------------------------- 3278 # 3279 + ", '" + str( plPrtDokdoku[2] ) + "'" 3280 # 3281 # -- notizen ------------------------------------------ 3282 # 3283 + ", '" + str( plPrtDokdoku[3] ) + "']);" ) 3284 3285 3286 # 3287 # -- 3288 # -- Personen zuordnen -------------------------------------------------- 3289 # -- >prj.ppl_dokdoku< ---------- 3290 # -- ---------- 3291 # -- Zur vorgegebenen >dok_doku_id< werden die Personen direkt ---------- 3292 # -- aus der Datenbank gelesen und das aktuelle Projekt zugeordnet ---------- 3293 # -- ---------- 3294 # -- ---------- 3295 # -- prj.nimm__tabwerte( 'ppl_dokdoku', ARRAY[ ---------- 3296 # -- 1. prj_projekte_id ---------- 3297 # -- 2. dok_doku_id ---------- 3298 # -- 3. prj_personen_id ---------- 3299 # -- 4. logentfernt ---------- 3300 # -- 5. notizen ---------- 3301 # -- ---------- 3302 # -- ---------- 3303 # -- -------------------------------------------------------------------------- 3304 # 3305 werte = [] 3306 self.__dbAbfrage__( """ 3307 -- 3308 -- Zugeordnete Personen auslesen 3309 -- 3310 SELECT DISTINCT 3311 -- 0 3312 prj__ppl_dokdoku__prj_personen_id AS prj_personen_id 3313 , prj__ppl_dokdoku__notizen AS notizen 3314 FROM 3315 prj.zeige__ppl_dokdoku_le 3316 , prj.zeige__dokdoku 3317 WHERE 3318 -- 3319 -- Ausschließlich die letzten (aktuellen) Personenzuordnungen anzeigen, ... 3320 -- 3321 prj.zeige__ppl_dokdoku_le.prj__ppl_dokdoku__id = 3322 prj.zeige__dokdoku.prj__ppl_dokdoku__id 3323 AND 3324 -- 3325 -- ... die nicht entfernt wurden 3326 -- 3327 prj.zeige__dokdoku.prj__ppl_dokdoku__logentfernt = false 3328 AND 3329 -- 3330 -- Dokument festlegen 3331 -- 3332 prj.zeige__dokdoku.dok__doku__id = """ + str( dokDokuId ) + """ 3333 ;""" ) 3334 3335 for i in range( self.__gibAnzZeilen__() ): 3336 werte.append( [ self.__gibWert__( i, 0 ), self.__gibWert__( i, 1 ) ] ) 3337 3338 for i in range( len( werte ) ) : 3339 self.__dbAbfrage__( """ 3340 SELECT prj.nimm__tabwerte( 'ppl_dokdoku', ARRAY[""" 3341 # 3342 # -- prj_projekte_id ---------------------------------- 3343 # 3344 + "'" + str( prjProjekteId ) + "'" 3345 # 3346 # -- dok_doku_id ------------------------------------------ 3347 # 3348 + ", '" + str( dokDokuId ) + "'" 3349 # 3350 # -- prj_personen_id ------------------------------------------ 3351 # 3352 + ", '" + str( werte[i][0] ) + "'" 3353 # 3354 # -- logentfernt ------------------------------------------ 3355 # 3356 + ", '" + str( logentfernt ) + "'" 3357 # 3358 # -- notizen ------------------------------------------ 3359 # 3360 + ", '" + str( werte[i][1] ) + "']);" ) 3361 3362 3363 3364 # 3365 # -- 3366 # -- Ausgabe zuordnen -------------------------------------------------- 3367 # -- >prj.pl_dokausgabe< ---------- 3368 # -- ---------- 3369 # -- ---------- 3370 # -- prj.nimm__tabwerte( 'pl_dokausgabe', ARRAY[ ---------- 3371 # -- 1. prj_projekte_id ---------- 3372 # -- 2. dok_doku_id ---------- 3373 # -- 3. logentfernt ---------- 3374 # -- 4. stand ---------- 3375 # -- 5. datum ---------- 3376 # -- 6. istfrei ---------- 3377 # -- 7. notizen ---------- 3378 # -- ---------- 3379 # -- ---------- 3380 # -- >prj.pl_dokausgabe.stand< muß einen Wert haben, sonst ist ---------- 3381 # -- keine Ausgabe zugeordnet ---------- 3382 # -- ---------- 3383 # -- ---------- 3384 # -- -------------------------------------------------------------------------- 3385 # 3386 if( plDokAusgabe is None ) : return 3387 3388 if( len( str( plDokAusgabe[2] ) ) > 0 ) : 3389 3390 self.__dbAbfrage__( """ 3391 SELECT prj.nimm__tabwerte( 'pl_dokausgabe', ARRAY[""" 3392 # 3393 # -- prj_projekte_id ---------------------------------- 3394 # 3395 + "'" + str( prjProjekteId ) + "'" 3396 # 3397 # -- dok_doku_id ------------------------------------------ 3398 # 3399 + ", '" + str( dokDokuId ) + "'" 3400 # 3401 # -- logentfernt ------------------------------------------ 3402 # 3403 + ", '" + str( logentfernt ) + "'" 3404 # 3405 # -- stand -------------------------------------------------- 3406 # 3407 + ", '" + str( plDokAusgabe[0] ) + "'" 3408 # 3409 # -- datum -------------------------------------------------- 3410 # 3411 + ", '" + str( plDokAusgabe[1] ) + "'" 3412 # 3413 # -- istfrei -------------------------------------------------- 3414 # 3415 + ", '" + str( plDokAusgabe[2] ) + "'" 3416 # 3417 # -- notizen ------------------------------------------ 3418 # 3419 + ", '" + str( plDokAusgabe[3] ) + "']);" )

3420 3421 3422 3423 # 3424 # ------------------------------------------------------------------------------------ 3425 # -- Protokolleintrag dem Gefahrenszenario zuordnen -------------------------- 3426 # ------------------------------------------------------------------------------------ 3427 #

3428 - def schreibe__prjPrtPsGefszenario( self, TreeCtrlErg, prjProjekteId, psGefszenarioId, logentfernt = 'false' ):

3429 """ 3430 Methode zum Herstellen der projektspezifischen Verbindung zwischen Protokolleintrag und Dokument. 3431 3432 @note: Die übergebene Auswahlliste (C{SiAnfStrktDok}) wird verändert ! 3433 3434 @param SiAnfStrktDokTreeCtrlErgPyData: Es ist das Datenobjekt zum C{TreeCtrlErg-Objekt} der Dokumente zu übergeben. 3435 @type SiAnfStrktDokTreeCtrlErgPyData: wxPython - TreeCtrlErg (Datenobjekt) 3436 3437 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 3438 @type prjProjekteId: Ganzzahl 3439 3440 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 3441 @type psGefszenarioId: Ganzzahl 3442 3443 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 3444 @type logentfernt: Zeichenkette, die C{true/false} enthält 3445 """ 3446 3447 # 3448 # -- alle >prt.protokoll.id< aus der Datenbank holen, die dem ---------- 3449 # -- Gefahrenszenario bereits zugeordnet sind ---------- 3450 # -- (nur beim Zuordnen relevant) ---------- 3451 # 3452 prtProtokollIdZugeordnet = [] 3453 3454 if( not logentfernt ) : 3455 3456 self.__dbAbfrage__( self.gibSQL_prjPlPrtPsGefszenario( prjProjekteId = prjProjekteId 3457 , psGefszenarioId = psGefszenarioId ) ) 3458 3459 for i in range( self.__gibAnzZeilen__() ): 3460 3461 prtProtokollIdZugeordnet.append( self.__gibWert__( i, 0 ) ) 3462 3463 3464 3465 # 3466 # -- 3467 # -- Protokolleintrag und Gefahrenszenario verbinden -------------------------- 3468 # -- >prj.pl_prtpsgefszenario< ---------- 3469 # -- ---------- 3470 # -- ---------- 3471 # -- prj.nimm__tabwerte( 'pl_prtpsgefszenario', ARRAY[ ---------- 3472 # -- 1. prj_projekte_id ---------- 3473 # -- 2. ps_gefszenario_id ---------- 3474 # -- 3. prt_protokoll_id ---------- 3475 # -- 4. notizen ---------- 3476 # -- 5. logentfernt ---------- 3477 # -- 6. ... ---------- 3478 # -- ---------- 3479 # -- -------------------------------------------------------------------------- 3480 # 3481 eintragListe = TreeCtrlErg.gibZweig( eintrag = TreeCtrlErg.GetSelection() ) 3482 3483 for i in range( len( eintragListe ) ) : 3484 3485 # 3486 # -- bereits zugeordnete Protokolleinträge überspringen, ---------- 3487 # -- (beim Entfernen ist >prtProtokollIdZugeordnet< leer ) ---------- 3488 # 3489 if( TreeCtrlErg.gibDbId( eintragListe[i] ) in prtProtokollIdZugeordnet ) : 3490 continue 3491 3492 self.__dbAbfrage__( """ 3493 SELECT prj.nimm__tabwerte( 'pl_prtpsgefszenario', ARRAY[""" 3494 # 3495 # -- prj_projekte_id ---------------------------------- 3496 # 3497 + "'" + str( prjProjekteId ) + "'" 3498 # 3499 # -- ps_gefszenario_id ---------------------------------- 3500 # 3501 + ", '" + str( psGefszenarioId ) + "'" 3502 # 3503 # -- prt_protokoll_id ---------------------------------- 3504 # 3505 + ", '" + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) + "'" 3506 # 3507 # -- notizen (ggf. später den tatsächlichen Wert übernehmen) -- 3508 # 3509 + ", '" + zk.gibZk( "" ) + "'" 3510 # 3511 # -- logentfernt ------------------------------------------ 3512 # 3513 + ", '" + logentfernt + "']);" )

3514 3515 3516 3517 3518 # 3519 # ------------------------------------------------------------------------------------ 3520 # -- Alle Eingabefelder des Gefahrenprotokolls in Abhängigkeit ---------- 3521 # -- von der gewählten Protokoll.-Id schreiben ---------- 3522 # ------------------------------------------------------------------------------------ 3523 #

3524 - def schreibePrtProtokoll( self, wxCheckBoxIntern, wxCheckBoxErledigt, wxComboBoxTypPE, wxmskCtrlDatumPE, LBSpWTALBetPers, listeWerte, wxmskCtrlAntwDatum, wxmskCtrlTermin, LBSpWTALAntwPers, fallunterscheidung, prjProjekteId, sprSprachenId, prtProtokollId ):

3525 """ 3526 Methode zum Einfügen / Aktualisieren der projektspezifischen Informationen in die Datenbanktabellen C{prt.protokoll / prj.pp_prtprotokoll}. 3527 3528 @param wxCheckBoxIntern: CheckBox zur Markierung 'Intern' 3529 @type wxCheckBoxIntern: wxPython - CheckBox 3530 3531 @param wxCheckBoxErledigt: CheckBox zur Markierung 'Erledigt' 3532 @type wxCheckBoxErledigt: wxPython - CheckBox 3533 3534 @param wxComboBoxTypPE: ComboBox aus der der Typ des Protokolleintrages entnehmbar ist 3535 @type wxComboBoxTypPE: wxPython - ComboBox 3536 3537 @param wxmskCtrlDatumPE: Datum-Eingabefeld, zur Spezifikation des Datums des Protokolleintrages 3538 @type wxmskCtrlDatumPE: wxPython - wxmskCtrl 3539 3540 @param LBSpWTALBetPers: Auswahlliste, die die beteiligten Personen aufnimmt 3541 @type LBSpWTALBetPers: ListBoxSpWTitelAL 3542 3543 @param listeWerte: Es sind C{[prj.pp_prtprotokoll.id, notizen]} zu übergeben 3544 @type listeWerte: Python-Liste 3545 3546 @param wxmskCtrlAntwDatum: Datum-Eingabefeld, zur Spezifikation des Datums der Antwort 3547 @type wxmskCtrlAntwDatum: wxPython - wxmskCtrl 3548 3549 @param wxmskCtrlTermin: Datum-Eingabefeld, zur Spezifikation des Termins 3550 @type wxmskCtrlTermin: wxPython - wxmskCtrl 3551 3552 @param LBSpWTALAntwPers: Auswahlliste, die die angesprochenen Personen aufnimmt 3553 @type LBSpWTALAntwPers: ListBoxSpWTitelAL 3554 3555 @param fallunterscheidung: Es ist zu unterscheiden, ob ein projektspezifischer Protokolleintrag C{fallunterscheidung == None}, beteiligte Personen C{fallunterscheidung == True} oder eine Frage / Aufgabe C{fallunterscheidung == False} vorliegt. 3556 @type fallunterscheidung: 3557 3558 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 3559 @type prjProjekteId: Ganzzahl 3560 3561 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 3562 @type sprSprachenId: Ganzzahl 3563 3564 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Protokolleintrages zu übergeben. 3565 @type prtProtokollId: Ganzzahl 3566 """ 3567 3568 3569 # 3570 # -- 3571 # -- Übersetzungsvariante >spr.uebvar< bereitstellen / bearbeiten ---------- 3572 # -- ---------- 3573 # -- ---------- 3574 # -- Rechtschreibfehlerkorrekturen >istRFKorr = True< haben globale ---------- 3575 # -- Auswirkungen (werden projektübergreifend übernommen) ---------- 3576 # -- Neben den Tabellen der Sicht >spr< werden keine weiteren ---------- 3577 # -- Datenbanktabellen verändert, deshalb wird die Änderung als ---------- 3578 # -- 'bearbeitet' markiert ---------- 3579 # -- ---------- 3580 # -- ---------- 3581 # -- Es werden drei Fälle abgedeckt: ---------- 3582 # -- ............................... ---------- 3583 # -- ---------- 3584 # -- 1. projektspezifischer Protokolleintrag ---------- 3585 # -- id > 0 AND prj_personen_id = 0 AND ---------- 3586 # -- prj_projekte_id > 0 AND prt_protokoll_id > 0 ---------- 3587 # -- ---------- 3588 # -- 2. beteiligte Personen zuordnen ---------- 3589 # -- id > 0 AND prj_personen_id > 0 AND prj_projekte_id > 0 ---------- 3590 # -- AND prt_protokoll_id > 0 AND spr_uebvar_id = 0 ---------- 3591 # -- AND teilnehmer = true ---------- 3592 # -- ---------- 3593 # -- 3. der Protokolleintrag ist eine Frage / Aufgabe ---------- 3594 # -- id > 0 AND prj_personen_id > 0 AND prj_projekte_id > 0 ---------- 3595 # -- AND prt_protokoll_id > 0 AND spr_uebvar_id = 0 ---------- 3596 # -- AND teilnehmer = false AND termin IS NOT NULL ---------- 3597 # -- ---------- 3598 # -- ---------- 3599 # -- Änderungen (Zeilen) in Liste schreiben (Tabelle ---------- 3600 # -- >prj.pp_prtprotokoll<) : ---------- 3601 # -- ---------- 3602 # -- werte[ 0 id ---------- 3603 # -- 1 notizen ---------- 3604 # -- 2 datuhrz ---------- 3605 # -- 3 duanfrage ---------- 3606 # -- 4 erledigt ---------- 3607 # -- 5 intern ---------- 3608 # -- 6 prj_personen_id ---------- 3609 # -- 7 prj_projekte_id ---------- 3610 # -- 8 prt_protokoll_id ---------- 3611 # -- 9 spr_uebvar_id ---------- 3612 # -- 10 teilnehmer ---------- 3613 # -- 11 termin ] ---------- 3614 # -- ---------- 3615 # -- ---------- 3616 # -- -------------------------------------------------------------------------- 3617 # 3618 werte = [] 3619 3620 3621 # 3622 # -- 3623 # -- 1. projektspezifischer Protokolleintrag -------------------------- 3624 # -- 3625 # 3626 if( fallunterscheidung is None ) : 3627 3628 werte.append( [ listeWerte[0] 3629 , listeWerte[2] 3630 , wxmskCtrlDatumPE.gibWert() 3631 , None 3632 , wxCheckBoxErledigt.gibWert() 3633 , wxCheckBoxIntern.gibWert() 3634 , 0 3635 , prjProjekteId 3636 , prtProtokollId 3637 , listeWerte[1] 3638 , None 3639 , None] ) 3640 3641 3642 3643 # 3644 # -- 3645 # -- 2. Beteiligte Personen -------------------------------------------------- 3646 # -- 3647 # 3648 if( LBSpWTALBetPers.ListBox__li.gibClientData() == None ): 3649 tmp = 0 3650 else : 3651 tmp = len( LBSpWTALBetPers.ListBox__li.gibClientData() ) 3652 3653 if( fallunterscheidung == True ) : 3654 3655 for i in range( tmp ): 3656 if( i < len( LBSpWTALBetPers.ListBox__li.clientData ) ) : 3657 # Personen übernehmen / überschreiben 3658 werte.append( [ LBSpWTALBetPers.ListBox__li.clientData[i] 3659 , None 3660 , None 3661 , None 3662 , None 3663 , None 3664 , LBSpWTALBetPers.ListBox__li.gibClientData(i)[0] 3665 , prjProjekteId 3666 , prtProtokollId 3667 , None 3668 , 'true' 3669 , None] ) 3670 else : 3671 # Personen hinzufügen 3672 werte.append( [ None 3673 , None 3674 , None 3675 , None 3676 , None 3677 , None 3678 , LBSpWTALBetPers.ListBox__li.gibClientData(i)[0] 3679 , prjProjekteId 3680 , prtProtokollId 3681 , None 3682 , 'true' 3683 , None] ) 3684 # Personen löschen 3685 for i in range( tmp, len( LBSpWTALBetPers.ListBox__li.clientData ) ): 3686 werte.append( [ LBSpWTALBetPers.ListBox__li.clientData[i] 3687 , None 3688 , None 3689 , None 3690 , None 3691 , None 3692 , None 3693 , prjProjekteId 3694 , prtProtokollId 3695 , None 3696 , 'true' 3697 , None] ) 3698 3699 3700 # 3701 # -- 3. der Protokolleintrag ist eine Frage / Aufgabe ------------------ 3702 # 3703 if( LBSpWTALAntwPers.ListBox__li.gibClientData() == None ): 3704 tmp = 0 3705 else : 3706 tmp = len( LBSpWTALAntwPers.ListBox__li.gibClientData() ) 3707 3708 if( fallunterscheidung == False ) : 3709 3710 for i in range( tmp ): 3711 if( i < len( LBSpWTALAntwPers.ListBox__li.clientData ) ) : 3712 # Personen übernehmen / überschreiben 3713 werte.append( [ LBSpWTALAntwPers.ListBox__li.clientData[i] 3714 , None 3715 , None 3716 , wxmskCtrlAntwDatum.gibWert() 3717 , None 3718 , None 3719 , LBSpWTALAntwPers.ListBox__li.gibClientData(i) 3720 , prjProjekteId 3721 , prtProtokollId 3722 , None 3723 , 'false' 3724 , wxmskCtrlTermin.gibWert()] ) 3725 else : 3726 # Personen hinzufügen 3727 werte.append( [ None 3728 , None 3729 , None 3730 , wxmskCtrlAntwDatum.gibWert() 3731 , None 3732 , None 3733 , LBSpWTALAntwPers.ListBox__li.gibClientData(i) 3734 , prjProjekteId 3735 , prtProtokollId 3736 , None 3737 , 'false' 3738 , wxmskCtrlTermin.gibWert()] ) 3739 3740 # Personen löschen 3741 for i in range( tmp, len( LBSpWTALAntwPers.ListBox__li.clientData ) ): 3742 if( i < len( LBSpWTALAntwPers.ListBox__li.clientData ) ) : 3743 werte.append( [ LBSpWTALAntwPers.ListBox__li.clientData[i] 3744 , None 3745 , None 3746 , wxmskCtrlAntwDatum.gibWert() 3747 , None 3748 , None 3749 , None 3750 , prjProjekteId 3751 , prtProtokollId 3752 , None 3753 , 'false' 3754 , wxmskCtrlTermin.gibWert()] ) 3755 3756 3757 3758 # 3759 # -- 3760 # -- >prj.pp_prtprotokoll< -------------------------------------------------- 3761 # -- ---------- 3762 # -- ---------- 3763 # -- Es werden die projektspezifisch gültigen Zeilen eingelesen. ---------- 3764 # -- Wenn werte[6] == None (aktuelle >prj_personen_id< entfernt ---------- 3765 # -- wurde) wird der zugeordnete Protokolleintrag ---------- 3766 # -- >prj.pp_prtprotokoll.id< entfernt. ---------- 3767 # -- ---------- 3768 # -- ---------- 3769 # -- -------------------------------------------------------------------------- 3770 # 3771 for i in range( len( werte ) ) : 3772 3773 prj_personen_id = werte[i][6] 3774 3775 # 3776 # -- 3777 # -- Protokolleinträge aus >prj.pp_prtprotokoll< entfernen ---------- 3778 # -- -- 3779 # -- -- 3780 # -- SELECT intern.loesche__zeile( 'prj.pp_prtprotokoll' -- 3781 # -- , 'prj.pp_prtprotokoll.id = werte[i][0]' ); -- 3782 # -- -- 3783 # -- -- 3784 # -- ------------------------------------------------------------------ 3785 # 3786 if( prj_personen_id == None ) : 3787 3788 self.__dbAbfrage__( """ 3789 SELECT intern.loesche__zeile( 'prj.pp_prtprotokoll' 3790 , 'prj.pp_prtprotokoll.id = """ + str( werte[i][0] ) + """' 3791 , 'true');""" ) 3792 3793 3794 # 3795 # -- 3796 # -- Projektspezifische Zeilen einlesen -------------------------- 3797 # -- -- 3798 # -- -- 3799 # -- intern.nimm__zeile( 'prj.pp_prtprotokoll', ARRAY[ -- 3800 # -- 'id' -- 3801 # -- , 'notizen' -- 3802 # -- , 'datuhrz' -- 3803 # -- , 'duanfrage' -- 3804 # -- , 'erledigt' -- 3805 # -- , 'intern' -- 3806 # -- , 'prj_personen_id' -- 3807 # -- , 'prj_projekte_id' -- 3808 # -- , 'prt_protokoll_id' -- 3809 # -- , 'spr_uebvar_id' -- 3810 # -- , 'teilnehmer' -- 3811 # -- , 'termin' -- 3812 # -- ], ARRAY[...] ) -- 3813 # -- -- 3814 # -- Es werden die bisher bestehenden projektspezifischen Zeilen -- 3815 # -- überschrieben. -- 3816 # -- -- 3817 # -- -- 3818 # -- ------------------------------------------------------------------ 3819 # 3820 else : 3821 sql = "SELECT intern.nimm__zeile( 'prj.pp_prtprotokoll', ARRAY[" 3822 # 3823 # -- 0. id -------------------------------------------------- 3824 # 3825 if( werte[i][0] != None ) : sql = sql + "'id', " 3826 # 3827 # -- 1. notizen -------------------------------------------------- 3828 # 3829 if( werte[i][1] != None ) : sql = sql + "'notizen', " 3830 # 3831 # -- 2. datuhrz -------------------------------------------------- 3832 # 3833 if( werte[i][2] != None ) : sql = sql + "'datuhrz', " 3834 # 3835 # -- 3. duanfrage ------------------------------------------ 3836 # 3837 if( werte[i][3] != None ) : sql = sql + "'duanfrage', " 3838 # 3839 # -- 4. erledigt ------------------------------------------ 3840 # 3841 if( werte[i][4] != None ) : sql = sql + "'erledigt', " 3842 # 3843 # -- 5. intern -------------------------------------------------- 3844 # 3845 if( werte[i][5] != None ) : sql = sql + "'intern', " 3846 # 3847 # -- 6. prj_personen_id ------------------------------------------ 3848 # 3849 if( werte[i][6] != None ) : sql = sql + "'prj_personen_id', " 3850 # 3851 # -- 7 prj_projekte_id ------------------------------------------ 3852 # 3853 sql = sql + "'prj_projekte_id', " 3854 # 3855 # -- 8 prt_protokoll_id ---------------------------------- 3856 # 3857 sql = sql + "'prt_protokoll_id', " 3858 # 3859 # -- 9. spr_uebvar_id ------------------------------------------ 3860 # 3861 if( werte[i][9] != None ) : sql = sql + "'spr_uebvar_id', " 3862 # 3863 # -- 10. teilnehmer ------------------------------------------ 3864 # 3865 if( werte[i][10] != None ) : sql = sql + "'teilnehmer', " 3866 # 3867 # -- 11. termin -------------------------------------------------- 3868 if( werte[i][11] != None ) : sql = sql + "'termin', " 3869 3870 sql = sql + "], ARRAY['" 3871 3872 # 3873 # -- 0 id -------------------------------------------------- 3874 # 3875 if( werte[i][0] != None ) : sql = sql + str( werte[i][0] ) + """', '""" 3876 # 3877 # -- 1 notizen -------------------------------------------------- 3878 # 3879 if( werte[i][1] != None ) : sql = sql + str( werte[i][1] ) + """', '""" 3880 # 3881 # -- 2 datuhrz -------------------------------------------------- 3882 # 3883 if( werte[i][2] != None ) : sql = sql + zk.gibDatum( werte[i][2] ) + """', '""" 3884 # 3885 # -- 3 duanfrage ------------------------------------------ 3886 # 3887 if( werte[i][3] != None ) : sql = sql + zk.gibDatum( werte[i][3] ) + """', '""" 3888 # 3889 # -- 4 erledigt ------------------------------------------ 3890 # 3891 if( werte[i][4] != None ) : sql = sql + str( werte[i][4] ) + """', '""" 3892 # 3893 # -- 5 intern -------------------------------------------------- 3894 # 3895 if( werte[i][5] != None ) : sql = sql + str( werte[i][5] ) + """', '""" 3896 # 3897 # -- 6 prj_personen_id ------------------------------------------ 3898 # 3899 if( werte[i][6] != None ) : sql = sql + str( werte[i][6] ) + """', '""" 3900 # 3901 # -- 7 prj_projekte_id ------------------------------------------ 3902 # 3903 sql = sql + str( werte[i][7] ) + """', '""" 3904 # 3905 # -- 8 prt_protokoll_id ---------------------------------- 3906 # 3907 sql = sql + str( werte[i][8] ) + """', '""" 3908 # 3909 # -- 9 spr_uebvar_id ------------------------------------------ 3910 # 3911 if( werte[i][9] != None ) : sql = sql + str( werte[i][9] ) + """', '""" 3912 # 3913 # -- 10 teilnehmer ------------------------------------------ 3914 # 3915 if( werte[i][10] != None ) : sql = sql + str( werte[i][10] ) + """', '""" 3916 # 3917 # -- 11 termin -------------------------------------------------- 3918 if( werte[i][11] != None ) : sql = sql + zk.gibDatum( werte[i][11] ) + """', '""" 3919 3920 sql = sql + "']);" 3921 sql = sql.replace( ", ]", "]" ).replace( ", ''", "" ) 3922 3923 self.__dbAbfrage__( sql )

3924 3925 3926 3927 3928 3929 3930 # 3931 # ------------------------------------------------------------------------------------ 3932 # -- Protokolleintrag dem Gefahrenszenario zuordnen -------------------------- 3933 # -- Protokolleintrag vom Gefahrenszenario trennen -------------------------- 3934 # ------------------------------------------------------------------------------------ 3935 #

3936 - def schreibe__prjPPrtVerbindung( self, TreeCtrlErg, prjProjekteId, prtProtokollIdVorg, sprSprachenId = None, psGefszenarioId = None ):

3937 """ 3938 Methode zum Herstellen bzw. Aufheben der projektspezifischen Verbindung zwischen den Protokolleinträgen. 3939 3940 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die Protokolleinträge enthält, die zugeordnet bzw. entfernt werden soll. 3941 @type TreeCtrlErg: TreeCtrlErg 3942 3943 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 3944 @type prjProjekteId: Ganzzahl 3945 3946 @param prtProtokollIdVorg: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Vorgängers des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben, wenn die Protokolleinträge in C{TreeCtrlErg} dem Protokolleintrag C{prtProtokollIdVorg} zugeordnet werden sollen. Es ist C{None} zu übergeben, wenn die Protokolleinträge in C{TreeCtrlErg} von ihrem Vorgänger im C{TreeCtrlErg} getrennt werden sollen. 3947 @type prtProtokollIdVorg: Ganzzahl 3948 3949 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 3950 @type sprSprachenId: Ganzzahl 3951 3952 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 3953 @type psGefszenarioId: Ganzzahl 3954 """ 3955 3956 # 3957 # -- Zweig der selektierten Protokolleinträge bestimmen ------------------ 3958 # 3959 eintragListe = TreeCtrlErg.gibZweig( eintrag = TreeCtrlErg.GetSelection() ) 3960 3961 3962 # 3963 # -- 3964 # -- Verbindung zwischen den Protokolleinträgen aufheben ------------------ 3965 # -- >prj.p_prtverbindung< ------------------ 3966 # -- ------------------ 3967 # 3968 if( prtProtokollIdVorg is None ) : 3969 3970 # 3971 # -- Es sind keine Verbindungen zwischen den SiAnf zu trennen -- 3972 # 3973 if( len( eintragListe ) == 1 3974 and ( TreeCtrlErg.GetItemParent( eintragListe[0] ) == TreeCtrlErg.GetRootItem() ) ) : 3975 3976 return 3977 3978 # 3979 # -- DB-Id des Vorgängers ermitteln, ggf. >eintragListe< kürzen -- 3980 # 3981 if( len( eintragListe ) == 1 ) : 3982 3983 prt_protokoll_id_vorg = TreeCtrlErg.gibDbId( TreeCtrlErg.GetItemParent( eintragListe[0] ) ) 3984 3985 else : 3986 3987 prt_protokoll_id_vorg = TreeCtrlErg.gibDbId( eintragListe[0] ) 3988 del eintragListe[0] 3989 3990 3991 3992 # 3993 # -- Protokolleinträge ermitteln, die demselben Vorgänger in einem -- 3994 # -- weiteren Gefahrenszenario des Projektes zugeordnet sind -- 3995 # 3996 prtProtokollIdListe = "" 3997 3998 for i in range( len( eintragListe ) ) : 3999 4000 if( i > 0 ) : prtProtokollIdListe = prtProtokollIdListe + ', ' 4001 prtProtokollIdListe = prtProtokollIdListe + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) 4002 4003 4004 self.__dbAbfrage__( self.gibSQL_psPrtProtokoll( prjProjekteId = prjProjekteId 4005 , sprSprachenId = sprSprachenId 4006 , prtTypAspekt = 'SF' 4007 , psGefszenarioId = psGefszenarioId 4008 , sqlINpsGefszenId = False 4009 , prtProtokollIdVorg = prt_protokoll_id_vorg 4010 , prtProtokollIdNachf = prtProtokollIdListe ) ) 4011 4012 prtProtokollIdNichtTrennen = [] 4013 4014 for i in range( self.__gibAnzZeilen__() ) : prtProtokollIdNichtTrennen.append( self.__gibWert__( i, 3 ) ) 4015 4016 4017 # 4018 # -- Datenbank aktualisieren ------------------------------------------ 4019 # 4020 for i in range( len( eintragListe ) ) : 4021 4022 # 4023 # -- Protokolleinträge die demselben Vorgänger in einem ---------- 4024 # -- weiteren Gefahrenszenario des Projektes zugeordnet ---------- 4025 # -- sind, nicht trennen ---------- 4026 # 4027 if( TreeCtrlErg.gibDbId( eintragListe[i] ) in prtProtokollIdNichtTrennen ) : continue 4028 4029 # 4030 # -- Der zu löschenden Verbindung das Projekt '0' zuordnen ---------- 4031 # 4032 self.__dbAbfrage__( """ 4033 SELECT prj.nimm__tabwerte( 'p_prtverbindung', ARRAY[""" 4034 # 4035 # -- prj_projekte_id -------------------------- 4036 # 4037 + "'0'" 4038 # 4039 # -- prt_protokoll_id_nachf -------------------------- 4040 # 4041 + ", '" + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) + "'" 4042 # 4043 # -- prt_protokoll_id_vorg -------------------------- 4044 # 4045 + ", '" + str( prt_protokoll_id_vorg ) + "']);" ) 4046 4047 # 4048 # -- Verbindung im Projekt löschen ---------------------------------- 4049 # 4050 self.__dbAbfrage__( """ 4051 SELECT intern.loesche__zeile( 'prj.p_prtverbindung' 4052 , 'prj_projekte_id = """ + str( prjProjekteId ) + """ 4053 AND prt_protokoll_id_nachf = """ + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) + """ 4054 AND prt_protokoll_id_vorg = """ + str( prt_protokoll_id_vorg ) + """' 4055 , 'true');""" ) 4056 4057 4058 # 4059 # -- Ende, Verbindung aufheben ---------------------------------- 4060 # 4061 return 4062 4063 4064 # 4065 # -- 4066 # -- Protokolleinträge miteinander verbinden -------------------------- 4067 # -- >prj.p_prtverbindung< ---------- 4068 # -- ---------- 4069 # -- ---------- 4070 # -- prj.nimm__tabwerte( 'p_prtverbindung', ARRAY[ ---------- 4071 # -- 1. prj_projekte_id ---------- 4072 # -- 2. prt_protokoll_id_nachf ---------- 4073 # -- 3. prt_protokoll_id_vorg ---------- 4074 # -- 4. ... ---------- 4075 # -- ---------- 4076 # -- -------------------------------------------------------------------------- 4077 # 4078 for i in range( len( eintragListe ) ) : 4079 4080 # 4081 # -- Technische Maßnahmen überspringen -------------------------- 4082 # 4083 if( TreeCtrlErg.gibClientData( eintragListe[i] )[0] == True ) : 4084 continue 4085 4086 self.__dbAbfrage__( """ 4087 SELECT prj.nimm__tabwerte( 'p_prtverbindung', ARRAY[""" 4088 # 4089 # -- prj_projekte_id ---------------------------------- 4090 # 4091 + "'" + str( prjProjekteId ) + "'" 4092 # 4093 # -- prt_protokoll_id_nachf ---------------------------------- 4094 # 4095 + ", '" + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) + "'" 4096 # 4097 # -- prt_protokoll_id_vorg ---------------------------------- 4098 # 4099 + ", '" + str( prtProtokollIdVorg ) + "']);" )

4100 4101 4102 4103 4104 4105 4106 # 4107 # ------------------------------------------------------------------------------------ 4108 # -- Protokolleintrag dem Projekt zuordnen ---------------------------------- 4109 # ------------------------------------------------------------------------------------ 4110 #

4111 - def schreibe__prjPPPrtProtokoll( self, TreeCtrlErg, prjProjekteId, psGefszenarioId = None ):

4112 """ 4113 Methode zum Herstellen/Trennen der projektspezifischen Verbindung zwischen den Protokolleinträgen in C{TreeCtrlErg} und dem Projekt. 4114 4115 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die Protokolleinträge enthält, die dem Projekt zugeordnet bzw. aus dem Projekt entfernt werden sollen. 4116 @type TreeCtrlErg: TreeCtrlErg 4117 4118 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 4119 @type prjProjekteId: Ganzzahl 4120 4121 @param psGefszenarioId: Wenn die Protokolleinträge in C{TreeCtrlErg} vom Projekt getrennt werden sollen, ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. Wenn weitere Gefahrenszenarien im Projekt den jeweiligen Protokolleintrag verwenden, wird er nicht vom Projekt getrennt. Sollen die Protokolleinträge dem Projekt zugeordnet werden, ist C{None} zu übergeben. 4122 @type psGefszenarioId: Ganzzahl 4123 """ 4124 4125 # 4126 # -- Zweig der selektierten Protokolleinträge bestimmen ------------------ 4127 # 4128 eintragListe = TreeCtrlErg.gibZweig( eintrag = TreeCtrlErg.GetSelection() ) 4129 4130 4131 # 4132 # -- Verbindung zwischen Protokolleintrag und Projekt aufheben ---------- 4133 # 4134 if( psGefszenarioId is not None ) : 4135 4136 # 4137 # -- alle >prt.protokoll.id< aus der Datenbank holen, die im ---------- 4138 # -- Projekt einem weiteren Gefahrenszenario zugeordnet sind ---------- 4139 # 4140 self.__dbAbfrage__( self.gibSQL_prjPlPrtPsGefszenario( prjProjekteId 4141 , psGefszenarioId 4142 , sqlINpsGefszenId = False ) ) 4143 4144 prtProtokollIdNichtTrennen = [] 4145 4146 for i in range( self.__gibAnzZeilen__() ): 4147 4148 prtProtokollIdNichtTrennen.append( self.__gibWert__( i, 0 ) ) 4149 4150 4151 # 4152 # -- Datenbank aktualisieren ------------------------------------------ 4153 # 4154 for i in range( len( eintragListe ) ) : 4155 4156 # 4157 # -- Protokolleinträge die im Projekt einem weiteren ---------- 4158 # -- Gefahrenszenario zugeordnet sind, nicht trennen ---------- 4159 # 4160 if( TreeCtrlErg.gibDbId( eintragListe[i] ) in prtProtokollIdNichtTrennen ) : continue 4161 4162 4163 # 4164 # -- Dem vom Projekt zu lösenden Protokolleintrag das ---------- 4165 # -- Projekt '0' zuordnen ---------- 4166 # 4167 self.__dbAbfrage__( """ 4168 SELECT prj.nimm__tabwerte( 'pp_prtprotokoll', ARRAY[""" 4169 # 4170 # -- prj_projekte_id -------------------------- 4171 # 4172 + "'" + str( prjProjekteId ) + "'" 4173 # 4174 # -- prt_protokoll_id -------------------------- 4175 # 4176 + ", '" + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) + "'" 4177 # 4178 # -- spr_uebvar_id ---------------------------------- 4179 # 4180 + ", '" + str( TreeCtrlErg.gibClientData( eintragListe[i] )[1] ) + "'" 4181 # 4182 # -- datuhrz ---------------------------------- 4183 # -- intern ---------------------------------- 4184 # -- erledigt ---------------------------------- 4185 # 4186 + ", '1900-01-01', 'true', 'false'" 4187 # 4188 # -- notizen ---------------------------------- 4189 # 4190 + ", '" + TreeCtrlErg.gibClientData( eintragListe[i] )[2] + "']);" ) 4191 4192 # 4193 # -- Protokolleintrag im Projekt löschen -------------------------- 4194 # 4195 self.__dbAbfrage__( """ 4196 SELECT intern.loesche__zeile( 'prj.pp_prtprotokoll' 4197 , 'prj_projekte_id = """ + str( prjProjekteId ) + """ 4198 AND prt_protokoll = """ + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) + """' 4199 , 'true');""" ) 4200 4201 4202 # 4203 # -- Ende: Protokolleintrag vom Projekt trennen ------------------ 4204 # 4205 return 4206 4207 4208 4209 4210 # 4211 # -- 4212 # -- Protokolleintrag dem Projekt zuordnen ---------------------------------- 4213 # -- >prj.pp_prtprotokoll< ---------- 4214 # -- ---------- 4215 # -- ---------- 4216 # -- prj.nimm__tabwerte( 'pp_prtprotokoll', ARRAY[ ---------- 4217 # -- 1. prj_projekte_id ---------- 4218 # -- 2. prt_protokoll_id ---------- 4219 # -- 3. spr_uebvar_id ---------- 4220 # -- 4. datuhrz ---------- 4221 # -- 5. intern ---------- 4222 # -- 6. erledigt ---------- 4223 # -- 7. notizen ]... ---------- 4224 # -- ---------- 4225 # -- -------------------------------------------------------------------------- 4226 # 4227 eintragListe = TreeCtrlErg.gibZweig( eintrag = TreeCtrlErg.GetSelection() ) 4228 4229 for i in range( len( eintragListe ) ) : 4230 4231 self.__dbAbfrage__( """ 4232 SELECT prj.nimm__tabwerte( 'pp_prtprotokoll', ARRAY[""" 4233 # 4234 # -- prj_projekte_id ---------------------------------- 4235 # 4236 + "'" + str( prjProjekteId ) + "'" 4237 # 4238 # -- prt_protokoll_id ---------------------------------- 4239 # 4240 + ", '" + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) + "'" 4241 # 4242 # -- spr_uebvar_id ---------------------------------- 4243 # 4244 + ", '" + str( TreeCtrlErg.gibClientData( eintragListe[i] )[1] ) + "'" 4245 # 4246 # -- datuhrz ------------------------------------------ 4247 # -- intern ------------------------------------------ 4248 # -- erledigt ------------------------------------------ 4249 # 4250 + ", '1900-01-01', 'true', 'false'" 4251 # 4252 # -- notizen ------------------------------------------ 4253 # 4254 + ", '" + TreeCtrlErg.gibClientData( eintragListe[i] )[2] + "']);" )

4255 4256 4257 4258 4259 4260 4261 # 4262 # ------------------------------------------------------------------------------------ 4263 # -- Protokolleintrag mittels UPDATE aktualisieren -------------------------- 4264 # ------------------------------------------------------------------------------------ 4265 #

4266 - def schreibe__prjPPPrtProtokoll__UPDATE( self, sprUebvarId, whereId ):

4267 """ 4268 Methode zum Aktualisieren eines projektspezifischen Protokolleintrages C{prj.pp_prtprotokoll} mittels C{UPDATE}. 4269 4270 @param sprUebvarId: Es ist die Datenbankidentifikationsnummer (C{spr.uebvar.id}) der Übersetzungsvariante zu übergeben, die in C{prj.pp_prtprotokoll} übernommen werden soll. 4271 @type sprUebvarId: Ganzzahl 4272 4273 @param whereId: Es sind als Liste C{prj_projekte_id, prt.protokoll_id, spr_uebvar_id} zu übergeben, die in der C{WHERE} Bedingung für C{UPDATE} verwendet werden. 4274 @type whereId: Python-Liste 4275 """ 4276 4277 # 4278 # -- Datenbank aktualisieren ------------------------------------------ 4279 # 4280 self.__dbAbfrage__( """ 4281 UPDATE prj.pp_prtprotokoll SET spr_uebvar_id = """ + str( sprUebvarId ) + """ 4282 WHERE prj_projekte_id = """ + str( whereId[0] ) + """ 4283 AND prt_protokoll_id = """ + str( whereId[1] ) + """ 4284 AND spr_uebvar_id = """ + str( whereId[2] ) + """;""" )

4285 4286 4287 4288 4289 4290 4291 # 4292 # ------------------------------------------------------------------------------------ 4293 # -- Tabelle >prj.pl_psgefabk< schreiben ---------------------------------- 4294 # ------------------------------------------------------------------------------------ 4295 #

4296 - def schreibe__prjPlPsGefsabk( self, listeWerte, prjProjekteId, psGefszenarioId, logentfernt = 'false' ):

4297 """ 4298 Methode zum Übernehmen der projektspezifischen Abkürzungen bezogen auf das Gefahrenszenario. 4299 4300 @param listeWerte: Es sind C{[ps_abk_id, spr_uebvar_id_zus, notizen]} zu übergeben 4301 @type listeWerte: Python Liste 4302 4303 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 4304 @type prjProjekteId: Ganzzahl 4305 4306 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 4307 @type psGefszenarioId: Ganzzahl 4308 4309 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 4310 @type logentfernt: Zeichenkette, die C{true/false} enthält 4311 """ 4312 4313 # 4314 # -- 4315 # -- Projektspezifische Zeilen einlesen -------------------------- 4316 # -- -- 4317 # -- -- 4318 # -- prj.nimm__tabwerte( 'pl_psgefabk', ARRAY[ -- 4319 # -- 1. prj_projekte_id -- 4320 # -- 2. ps_gefszenario_id -- 4321 # -- 3. logentfernt -- 4322 # -- 4. ps_abk_id -- 4323 # -- 5. spr_uebvar_id_zus -- 4324 # -- 6. notizen -- 4325 # -- 7. ... ] ) -- 4326 # -- -- 4327 # -- -- 4328 # -- ------------------------------------------------------------------ 4329 # 4330 self.__dbAbfrage__( """ 4331 SELECT prj.nimm__tabwerte( 'pl_psgefabk', ARRAY[""" 4332 # 4333 # -- prj_projekte_id ---------------------------------- 4334 # 4335 + "'" + str( prjProjekteId ) + "'" 4336 # 4337 # -- ps_gefszenario_id ---------------------------------- 4338 # 4339 + ", '" + str( psGefszenarioId ) + "'" 4340 # 4341 # -- logentfernt ------------------------------------------ 4342 # 4343 + ", '" + logentfernt + "'" 4344 # 4345 # -- ps_abk_id ------------------------------------------ 4346 # 4347 + ", '" + str( listeWerte[0] ) + "'" 4348 # 4349 # -- spr_uebvar_id_zus 4350 # 4351 + ", '" + str( listeWerte[1] ) + "'" 4352 # 4353 # -- notizen ---------------------------------- 4354 # 4355 + ", '" + unicode( listeWerte[2] ) + "']);" )

4356 4357 4358 4359 4360 4361 # 4362 # ------------------------------------------------------------------------------------ 4363 # -- Tabelle >prj.pl_psgefanm< schreiben ---------------------------------- 4364 # ------------------------------------------------------------------------------------ 4365 #

4366 - def schreibe__PrjPlPsGefAnm( self, listeWerte, prjProjekteId, psGefszenarioId, logentfernt = 'false' ):

4367 """ 4368 Methode zum Aktualisieren der projektspezifischen Anmerkungen in der Datenbanktabelle C{prj.pl_psgefanm}. 4369 4370 @param listeWerte: Es sind C{[ps_anmerkung_id, spr_uebvar_id, notizen} zu übergeben 4371 @type listeWerte: Python Liste 4372 4373 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id > 0}) des Projektes zu übergeben. 4374 @type prjProjekteId: Ganzzahl 4375 4376 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 4377 @type psGefszenarioId: Ganzzahl 4378 4379 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Anmerkung und Gefahrenszenario gelöst werden 4380 @type logentfernt: Zeichenkette, die C{true/false} enthält 4381 """ 4382 4383 4384 4385 # 4386 # -- 4387 # -- Projektspezifische Zeilen einlesen ---------------------------------- 4388 # -- ---------- 4389 # -- ---------- 4390 # -- prj.nimm__tabwerte( 'pl_psgefanm', ARRAY[ ---------- 4391 # -- 1. prj_projekte_id ---------- 4392 # -- 2. ps_gefszenario_id ---------- 4393 # -- 3. logentfernt ---------- 4394 # -- 4. ps_anmerkung_id ---------- 4395 # -- 5. spr_uebvar_id ---------- 4396 # -- 6. notizen ---------- 4397 # -- 7. ... ] ) ---------- 4398 # -- ---------- 4399 # -- Momentan wird nicht geprüft, ob die aktuell einzulesende ---------- 4400 # -- projektspezifische Zeile in der Datenbank die aktuell gül- ---------- 4401 # -- tige Zeile ist (einfacherer Algorithmus). Das kann später ---------- 4402 # -- verbessert werden. ---------- 4403 # -- ---------- 4404 # -- ---------- 4405 # -- -------------------------------------------------------------------------- 4406 # 4407 self.__dbAbfrage__( """ 4408 SELECT prj.nimm__tabwerte( 'pl_psgefanm', ARRAY[""" 4409 # 4410 # -- prj_projekte_id ------------------------------------------ 4411 # 4412 + "'" + str( prjProjekteId ) + "'" 4413 # 4414 # -- ps_gefszenario_id ------------------------------------------ 4415 # 4416 + ", '" + str( psGefszenarioId ) + "'" 4417 # 4418 # -- logentfernt -------------------------------------------------- 4419 # 4420 + ", '" + logentfernt + "'" 4421 # 4422 # -- ps_anmerkung_id 4423 # 4424 + ", '" + str( listeWerte[0] ) + "'" 4425 # 4426 # -- spr_uebvar_id 4427 # 4428 + ", '" + str( listeWerte[1] ) + "'" 4429 # 4430 # -- notizen ------------------------------------------ 4431 # 4432 + ", '" + listeWerte[2].encode('utf-8') + "']);" )

4433 4434 4435 4436 4437 # 4438 # ------------------------------------------------------------------------------------ 4439 # -- Tabelle >prj.pl_psgefstrkt< schreiben ---------------------------------- 4440 # ------------------------------------------------------------------------------------ 4441 #

4442 - def schreibe__PrjPlPsGefStrkt( self, listeWerte, prjProjekteId, psGefszenarioId, logentfernt = 'false' ):

4443 """ 4444 Methode zum Einfügen / Aktualisieren der (projektspezifischen) Informationen in die Datenbanktabellen C{prj.pl_psgefstrkt}. 4445 4446 @param listeWerte: Es sind C{[str_strkt_id, notizen]} zu übergeben 4447 @type listeWerte: Python Liste 4448 4449 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 4450 @type prjProjekteId: Ganzzahl 4451 4452 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 4453 @type psGefszenarioId: Ganzzahl 4454 4455 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 4456 @type logentfernt: Zeichenkette, die C{true/false} enthält 4457 """ 4458 4459 4460 # 4461 # -- 4462 # -- Projektspezifische Zeilen einlesen ---------------------------------- 4463 # -- ---------- 4464 # -- ---------- 4465 # -- prj.nimm__tabwerte( 'pl_psgefstrkt', ARRAY[ ---------- 4466 # -- 1. prj_projekte_id ---------- 4467 # -- 2. ps_gefszenario_id ---------- 4468 # -- 3. str_strkt_id ---------- 4469 # -- 4. notizen ---------- 4470 # -- 5. logentfernt ---------- 4471 # -- 6. ... ] ) ---------- 4472 # -- ---------- 4473 # -- ---------- 4474 # -- Momentan wird nicht geprüft, ob die aktuell einzulesende ---------- 4475 # -- projektspezifische Zeile in der Datenbank die aktuell gül- ---------- 4476 # -- tige Zeile ist (einfacherer Algorithmus). Das kann später ---------- 4477 # -- verbessert werden. ---------- 4478 # -- ---------- 4479 # -- ---------- 4480 # -- -------------------------------------------------------------------------- 4481 # 4482 self.__dbAbfrage__( """ 4483 SELECT prj.nimm__tabwerte( 'pl_psgefstrkt', ARRAY[""" 4484 # 4485 # -- prj_projekte_id ---------------------------------- 4486 # 4487 + "'" + str( prjProjekteId ) + "'" 4488 # 4489 # -- ps_gefszenario_id ---------------------------------- 4490 # 4491 + ", '" + str( psGefszenarioId ) + "'" 4492 # 4493 # -- str_strkt_id ------------------------------------------ 4494 # 4495 + ", '" + str( listeWerte[0] ) + "'" 4496 # 4497 # -- notizen ------------------------------------------ 4498 # 4499 + ", '" + listeWerte[1].encode('utf-8') + "'" 4500 # 4501 # -- logentfernt ------------------------------------------ 4502 # 4503 + ", '" + logentfernt + "']);" )

4504 4505 4506 4507 4508 # 4509 # ------------------------------------------------------------------------------------ 4510 # -- Tabelle >ps.gefszenario< -------------------------- 4511 # -- >prj.pp_psgefszenario< schreiben -------------------------- 4512 # ------------------------------------------------------------------------------------ 4513 #

4514 - def schreibe__PrjPpPsGefszenario( self, listeGefszen, spr_uebvar_id_reprgefszen, prjProjekteId, sprSprachenId, psGefszenarioId ):

4515 """ 4516 Methode zum Einfügen / Aktualisieren der (projektspezifischen) Informationen in die Datenbanktabellen C{ps.gefszenario / prj.pp_psgefszenario}. 4517 4518 4519 @param listeGefszen: Es ist das GUI-Element zu übergeben, welches das Gefahrenszenario einschließlich interner Notizen repräsentiert. 4520 @type listeGefszen: TextCtrlSpWTitel 4521 4522 @param spr_uebvar_id_reprgefszen: Es ist das GUI-Element zu übergeben, welches das repräsentative Gefahrenszenario repräsentiert. 4523 @type spr_uebvar_id_reprgefszen: TextCtrlErg 4524 4525 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 4526 @type prjProjekteId: Ganzzahl 4527 4528 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 4529 @type sprSprachenId: Ganzzahl 4530 4531 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 4532 @type psGefszenarioId: Ganzzahl 4533 """ 4534 4535 # 4536 # -- 4537 # -- Projektspezifische Zeilen einlesen ---------------------------------- 4538 # -- ---------- 4539 # -- ---------- 4540 # -- intern.nimm__zeile( 'prj.pp_psgefszenario', ARRAY[ ---------- 4541 # -- 'id' ---------- 4542 # -- , 'notizen' ---------- 4543 # -- , 'prj_personen_id' ---------- 4544 # -- , 'prj_projekte_id' ---------- 4545 # -- , 'ps_gefszenario_id' ---------- 4546 # -- , 'spr_uebvar_id' ---------- 4547 # -- , 'spr_uebvar_id_reprgefszen' ---------- 4548 # -- , 'spr_uebvar_id_ursp' ---------- 4549 # -- ], ARRAY[...] ) ---------- 4550 # -- ---------- 4551 # -- Es werden die bisher bestehenden projektspezifischen Zeilen ---------- 4552 # -- überschrieben. ---------- 4553 # -- ---------- 4554 # -- ---------- 4555 # -- -------------------------------------------------------------------------- 4556 # 4557 self.__dbAbfrage__( """ 4558 SELECT intern.nimm__zeile( 'prj.pp_psgefszenario', ARRAY[ 4559 'id' 4560 , 'notizen' 4561 , 'prj_personen_id' 4562 , 'prj_projekte_id' 4563 , 'ps_gefszenario_id' 4564 , 'spr_uebvar_id' 4565 , 'spr_uebvar_id_reprgefszen' 4566 , 'spr_uebvar_id_ursp' 4567 ], ARRAY['""" 4568 + str( listeGefszen[2] ) + """', '""" 4569 + listeGefszen[1].encode('utf-8') + """', '""" 4570 + '0' + """', '""" 4571 + str( prjProjekteId ) + """', '""" 4572 + str( psGefszenarioId ) + """', '""" 4573 + str( listeGefszen[0] ) + """', '""" 4574 + str( spr_uebvar_id_reprgefszen ) + """', '""" 4575 # 4576 # -- spr_uebvar_id_ursp ---------- 4577 # 4578 + str( listeGefszen[3] ) + """']);""" )

4579 4580 4581 4582 4583 4584 # 4585 # ------------------------------------------------------------------------------------ 4586 # -- Zugeordnete Dokumente selektieren ---------------------------------- 4587 # -- Sicht >prj.zeige__dokdoku< selektieren ---------------------------------- 4588 # ------------------------------------------------------------------------------------ 4589 #

4590 - def schreibe__psPrtStrkt( self, prjProjekteId, prtProtokollId, strStrktId, notizen, prjPPrtStrstrktId = None ):

4591 """ 4592 Methode zum Herstellen der projektspezifischen Verbindung zwischen Protokolleintrag und Strukturpunkt. 4593 4594 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 4595 @type prjProjekteId: Ganzzahl 4596 4597 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 4598 @type prtProtokollId: Ganzzahl 4599 4600 @param strStrktId : Es ist die Struktur-Id C{str.strkt.id} zu übergeben. 4601 @type strStrktId : C{Ganzzahl} 4602 4603 @param notizen -- Noch nicht implementiert -- : Es sind die Notizen zu übergeben. 4604 @type notizen : C{Zeichenkette} 4605 4606 @param prjPPrtStrstrktId: Wenn der Protokolleintrag vom Strukturpunkt getrennt werden soll, ist die Datenbankidentifikationsnummer (C{prj.p_prtstrstrkt.id}) der Verbindung übergeben. 4607 @type prjPPrtStrstrktId: Ganzzahl 4608 """ 4609 4610 # 4611 # -- 4612 # -- Protokolleintrag und Strukturpunkt trennen -------------------------- 4613 # -- >prj.p_prtstrstrkt< ---------- 4614 # -- ---------- 4615 # -- ---------- 4616 # -- SELECT intern.loesche__zeile( 'prj.p_prtstrstrkt' ---------- 4617 # -- , 'prj.p_prtstrstrkt.id = xxx' ---------- 4618 # -- , 'true' ); ---------- 4619 # -- ---------- 4620 # -- ---------- 4621 # -- -------------------------------------------------------------------------- 4622 # 4623 if( prjPPrtStrstrktId is not None ): 4624 4625 self.__dbAbfrage__( """ 4626 SELECT intern.loesche__zeile( 'prj.p_prtstrstrkt', 'prj.p_prtstrstrkt.id = """ 4627 + str( prjPPrtStrstrktId ) 4628 + """', 'true' );""" ) 4629 4630 4631 # 4632 # -- 4633 # -- Protokolleintrag und Strukturpunkt verbinden -------------------------- 4634 # -- >prj.p_prtstrstrkt< ---------- 4635 # -- ---------- 4636 # -- ---------- 4637 # -- prj.nimm__tabwerte( 'p_prtstrstrkt', ARRAY[ ---------- 4638 # -- 1. prj_projekte_id ---------- 4639 # -- 2. prt_protokoll_id ---------- 4640 # -- 3. str_strkt_id ---------- 4641 # -- 4. notizen ---------- 4642 # -- ---------- 4643 # -- ---------- 4644 # -- -------------------------------------------------------------------------- 4645 # 4646 else : 4647 4648 # 4649 # -- Verbindung herstellen ------------------------------------------ 4650 # 4651 self.__dbAbfrage__( """ 4652 SELECT prj.nimm__tabwerte( 'p_prtstrstrkt', ARRAY[""" 4653 # 4654 # -- prj_projekte_id ---------------------------------- 4655 # 4656 + "'" + str( prjProjekteId ) + "'" 4657 # 4658 # -- prt_protokoll_id ---------------------------------- 4659 # 4660 + ", '" + str( prtProtokollId ) + "'" 4661 # 4662 # -- str_strkt_id ------------------------------------------ 4663 # 4664 + ", '" + str( strStrktId ) + "']);" )

4665 # 4666 # -- notizen ------------------------------------------ 4667 # 4668 # + ", '" + notizen + "']);" ) 4669 4670 4671 4672 4673 4674 # 4675 # ------------------------------------------------------------------------------------ 4676 # -- In Tabelle >spr.uebvar< und weitere schreiben -------------------------- 4677 # -- (Übersetzungsvariante anlegen) -------------------------- 4678 # ------------------------------------------------------------------------------------ 4679 #

4680 - def schreibeSprNimmWgruppe( self, sprUebvarId, sprSprachenId, wgruppe, istRFKorr ):

4681 """ 4682 Methode zum Einlesen / Aktualisieren einer Übersetzungsvariante C{sprUebvarId}. Wenn eine Übersetzungsvariante C{sprUebvarId} aktualisiert werden soll, dann muß sie in der Datenbank vorhanden sein. Zur gegebenen Sprache C{sprSprachenId} muß nicht zwangsläufig eine Wortgruppe in der Datenbank vorhanden sein. 4683 4684 Zum Einlesen einer neuen Wortgruppe C{wgruppe} (und damit Übersetzungsvariante C{sprUebvarId}) muß C{sprUebvarId == None} und C{istRFKorr == None} gesetzt sein. 4685 4686 Zur Rechtschreibfehlerkorrektur einer Wortgruppe die in der aktuell gegebenen Sprache C{sprSprachenId} vorhanden und der gegebenen Übersetzungsvariante C{sprUebvarId} zugeordnet ist, muß C{istRFKorr == True} gesetzt sein. 4687 4688 Zur Anlage einer neuen Übersetzungsvariante, die auf der gegebenen Übersetzungsvariante C{sprUebvarId} basiert und die gegebene Wortgruppe C{wgruppe} in der gegebenen Sprache C{sprSprachenId} zuordnet, muß C{istRFKorr == False} gesetzt sein. 4689 4690 @param sprUebvarId: Es ist die Datenbankidentifikationsnummer (C{spr.uebvar.id}) der Übersetzungsvariante zu übergeben. 4691 @type sprUebvarId: Ganzzahl 4692 4693 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 4694 @type sprSprachenId: Ganzzahl 4695 4696 @param wgruppe: Aktuelle Übersetzung. 4697 @type wgruppe: Zeichenkette 4698 4699 @param istRFKorr: Die übergebe Übersetzung stellt eine Rechtschreibfehlerkorrektur dar. 4700 @type istRFKorr: boolean 4701 4702 @return: Wenn eine neue Übersetzungsvariante angelegt wird, wird deren C{spr.uebvar.id} zurückgegeben. Andernfalls wird C{None} zurückgegeben. 4703 @rtype: Ganzzahl 4704 """ 4705 4706 # 4707 # -- Es müssen Werte gegeben sein ------------------------------------------ 4708 # 4709 if( sprUebvarId == None or istRFKorr == None ) : 4710 if( not ( sprUebvarId == None and istRFKorr == None ) ) : 4711 raise SyntaxError('schreibeSprNimmWgruppe(...): Wenn >sprUebvarId == None< ist, dann muß >istRFKorr == None< sein.') 4712 4713 if( sprSprachenId == None 4714 or wgruppe == None ) : raise SyntaxError('schreibeSprNimmWgruppe(...): Außer >sprUebvarId< und >istRFKorr< darf keiner der Übergabewerte >None< sein. ') 4715 4716 4717 # 4718 # -- Vorhandene Übersetzungen auslesen/bearbeiten -------------------------- 4719 # -- ---------- 4720 # -- ---------- 4721 # -- -> Die zur Übersetzungsvariante >spr_uebvar_id< vorliegenden ---------- 4722 # -- Übersetzungen >spr_uebersetzung_id< ermitteln ---------- 4723 # -- ---------- 4724 # -- -> Die Übersetzungsvariante >spr_uebvar_id< muß im System ---------- 4725 # -- vorhanden sein ---------- 4726 # -- ---------- 4727 # -- -> Zur Übersetzungsvariante ist mindestens ein Datensatz ---------- 4728 # -- vorhanden -> vorhandene Übersetzungen bearbeiten ---------- 4729 # -- ---------- 4730 # -- ---------- 4731 # -- ---------- 4732 # -- werte[ 0 spr_uebersetzung_id ---------- 4733 # -- 1 spr_sprachen_id ---------- 4734 # -- 2 spr_wgruppe_id ] ---------- 4735 # -- ---------- 4736 # -- ---------- 4737 # -- -------------------------------------------------------------------------- 4738 # 4739 werte = [] 4740 hatUngueltigeSprache = False 4741 if( sprUebvarId != None ) : 4742 self.__dbAbfrage__( """ 4743 SELECT DISTINCT 4744 -- 0 4745 spr_uebersetzung_id 4746 , spr_sprachen_id 4747 -- 2 4748 , spr_wgruppe_id 4749 FROM 4750 spr.zeige__wgruppe 4751 WHERE 4752 -- Übersetzungsvariante angeben 4753 spr.zeige__wgruppe.spr_uebvar_id = """ + str( sprUebvarId ) + """ 4754 ;""" ) 4755 4756 if( not self.__hatWerte__() ) : 4757 tmp = 'schreibeSprNimmWgruppe(...): Die gegebene >sprUebvarId == ' + str( sprUebvarId ) + '< muß in der Datenbank vorhanden sein.' 4758 raise SyntaxError( tmp ) 4759 4760 for i in range( self.__gibAnzZeilen__() ): 4761 werte.append( [ self.__gibWert__( i, 0 ) 4762 , self.__gibWert__( i, 1 ) 4763 , self.__gibWert__( i, 2 ) ] ) 4764 4765 4766 4767 # 4768 # -- Keine Rechtschreibfehlerkorrektur >istRFKorr == False< ---------- 4769 # -- -- 4770 # -- -- 4771 # -- Es wird die nächste verfügbare >spr_uebvar_id< angelegt -- 4772 # -- (der Wert wird von >intern.nimm__zeile(...)< zurückgegeben) -- 4773 # -- -- 4774 # -- -- 4775 # -- ------------------------------------------------------------------ 4776 # 4777 spr_uebvar_id__neu = None 4778 4779 if( not istRFKorr ) : 4780 self.__dbAbfrage__( """ 4781 SELECT intern.nimm__zeile( 'spr.uebvar' 4782 , ARRAY[ 'id' ] 4783 , ARRAY[ CAST( intern.gib__naechsteid( 'spr.uebvar' ) AS varchar ) ] ); 4784 ;""" ) 4785 # ;""", 1 ) 4786 4787 # spr_uebvar_id__neu = self.__gibWert__( 0, 0, 1 ) 4788 spr_uebvar_id__neu = self.__gibWert__( 0, 0 ) 4789 4790 4791 # 4792 # -- Vorhandene Übersetzungen bearbeiten -------------------------- 4793 # -- -- 4794 # -- -- 4795 # -- Unter Berücksichtigung von >istRFKorr< werden die zur Über- -- 4796 # -- setzungsvariante >spr_uebvar_id = sprUebvarId< vorliegenden -- 4797 # -- Übersetzungen >spr_uebersetzung_id< bearbeitet -- 4798 # -- -- 4799 # -- -- 4800 # -- -> Rechtschreibfehlerkorrektur >istRFKorr == True< -- 4801 # -- (hat globale Auswirkung) -- 4802 # -- -- 4803 # -- Der in der aktuellen Sprache vorliegenden Übersetzung -- 4804 # -- >spr_uebersetzung_id< wird die ungültige Sprache '0' -- 4805 # -- zugeordnet -- 4806 # -- -- 4807 # -- -- 4808 # -- -> Keine Rechtschreibfehlerkorrektur >istRFKorr == False< -- 4809 # -- Alle vorliegenden Übersetzungen >spr_uebersetzung_id< -- 4810 # -- werden mit der neuen Übersetzungsvariante -- 4811 # -- >spr_uebvar_id == spr_uebvar_id__neu< angelegt (kopiert). -- 4812 # -- Außerdem wird der in der aktuellen Sprache vorliegenden -- 4813 # -- Übersetzung >spr_uebersetzung_id< die ungültige Sprache '0' -- 4814 # -- zugeordnet -- 4815 # -- -- 4816 # -- -- 4817 # -- ------------------------------------------------------------------ 4818 # 4819 for i in range( len( werte ) ) : 4820 # for i in range( self.__gibAnzZeilen__() ): 4821 4822 # 4823 # -- >istRFKorr == False< ---------------------------------- 4824 # -- Alle Übersetzungen kopieren ---------------------------------- 4825 # 4826 if( not istRFKorr ) : 4827 4828 self.__dbAbfrage__( """ 4829 SELECT intern.nimm__zeile( 'spr.uebersetzung' 4830 , ARRAY['spr_sprachen_id', 'spr_wgruppe_id', 'spr_uebvar_id'] 4831 , ARRAY['""" + str( werte[i][1] ) + """' 4832 , '""" + str( werte[i][2] ) + """' 4833 , '""" + str( spr_uebvar_id__neu ) + """'] ) 4834 ;""" ) 4835 # ;""", 1 ) 4836 4837 # self.__dbAbfrage__( """ 4838 # SELECT intern.nimm__zeile( 'spr.uebersetzung' 4839 # , ARRAY['spr_sprachen_id', 'spr_wgruppe_id', 'spr_uebvar_id'] 4840 # , ARRAY['""" + str( self.__gibWert__( i, 1 ) ) + """' 4841 # , '""" + str( self.__gibWert__( i, 2 ) ) + """' 4842 # , '""" + str( spr_uebvar_id__neu ) + """'] ) 4843 # ;""", 1 ) 4844 4845 4846 # 4847 # -- Ungültige Sprache '0' zuordnen ---------------------------------- 4848 # 4849 if( werte[i][1] == sprSprachenId ) : 4850 spr_uebersetzung_id = werte[i][0] 4851 # if( not istRFKorr ) : spr_uebersetzung_id = self.__gibWert__( 0, 0, 1 ) 4852 if( not istRFKorr ) : spr_uebersetzung_id = self.__gibWert__( 0, 0 ) 4853 4854 # if( self.__gibWert__( i, 1 ) == sprSprachenId ) : 4855 # spr_uebersetzung_id = self.__gibWert__( i, 0 ) 4856 # if( not istRFKorr ) : spr_uebersetzung_id = self.__gibWert__( 0, 0, 1 ) 4857 4858 self.__dbAbfrage__( """ 4859 UPDATE 4860 spr.uebersetzung 4861 SET 4862 spr_sprachen_id = 0 4863 WHERE 4864 -- Übersetzung angeben 4865 id = """ + str( spr_uebersetzung_id ) + """ 4866 ;""" ) 4867 # ;""", 1 ) 4868 4869 hatUngueltigeSprache = True 4870 4871 4872 # 4873 # -- ---------- 4874 # -- Aktuelle Wortgruppe einlesen ------------------------------------------ 4875 # -- ---------- 4876 # -- ---------- 4877 # -- -> Zur Übersetzungsvariante ist kein Datensatz vorhanden: ---------- 4878 # -- Es wird die aktuelle Wortgruppe eingelesen. ---------- 4879 # -- ---------- 4880 # -- -> Rechtschreibfehlerkorrektur >istRFKorr == True<: ---------- 4881 # -- Es wird die aktuelle Wortgruppe in der Übersetzungs- ---------- 4882 # -- variante >spr_uebvar_id = sprUebvarId< eingelesen ---------- 4883 # -- ---------- 4884 # -- -> Keine Rechtschreibfehlerkorrektur >istRFKorr == False< ---------- 4885 # -- Es wird die aktuelle Wortgruppe in der Übersetzungs- ---------- 4886 # -- variante >spr_uebvar_id = spr_uebvar_id__neu< ---------- 4887 # -- eingelesen ---------- 4888 # -- ---------- 4889 # -- ---------- 4890 # -- -------------------------------------------------------------------------- 4891 # 4892 tmpZk = "0" 4893 if( istRFKorr ) : tmpZk = str( sprUebvarId ) 4894 if( not istRFKorr and not istRFKorr == None) : tmpZk = str( spr_uebvar_id__neu ) 4895 4896 self.__dbAbfrage__( """ 4897 SELECT spr.nimm__wgruppe( '""" + wgruppe + """' 4898 , '""" + str( sprSprachenId ) + """' 4899 , '""" + tmpZk + """' ) 4900 ;""" ) 4901 # ;""", 1 ) 4902 4903 # tmpRW = self.__gibWert__( 0, 0, 1 ) 4904 tmpRW = self.__gibWert__( 0, 0 ) 4905 4906 4907 4908 # 4909 # -- Ungültige Übersetzung löschen ------------------------------------------ 4910 # -- ---------- 4911 # -- ---------- 4912 # -- -> Rechtschreibfehlerkorrektur >istRFKorr == True<: ---------- 4913 # -- Es wird die in der ungültigen Sprache '0' vorliegende ---------- 4914 # -- Übersetzung zur Übersetzungsvariante ---------- 4915 # -- >spr_uebvar_id = sprUebvarId< gelöscht ---------- 4916 # -- ---------- 4917 # -- -> Keine Rechtschreibfehlerkorrektur >istRFKorr == False< ---------- 4918 # -- Es wird die in der ungültigen Sprache '0' vorliegende ---------- 4919 # -- Übersetzung zur Übersetzungsvariante ---------- 4920 # -- >spr_uebvar_id = spr_uebvar_id__neu< gelöscht ---------- 4921 # -- ---------- 4922 # -- ---------- 4923 # -- -------------------------------------------------------------------------- 4924 # 4925 if( hatUngueltigeSprache ) : 4926 4927 self.__dbAbfrage__( """ 4928 SELECT intern.loesche__zeile( 'spr.uebersetzung' 4929 , 'spr.uebersetzung.id = """ + str( spr_uebersetzung_id ) + """' 4930 , 'true' );""" ) 4931 # , 'true' );""", 1 ) 4932 4933 4934 # 4935 # -- Übersetzungsvariante zurückgeben ---------------------------------- 4936 # -- ---------- 4937 # -- ---------- 4938 # -- -> Rechtschreibfehlerkorrektur >istRFKorr == True<: ---------- 4939 # -- Es wird die vorhandene Übersetzungsvariante ---------- 4940 # -- zurückgegeben ---------- 4941 # -- ---------- 4942 # -- -> In allen anderen Fällen wird die neu angelegte Über- ---------- 4943 # -- setzungsvariante zurückgegeben ---------- 4944 # -- ---------- 4945 # -- ---------- 4946 # -- -------------------------------------------------------------------------- 4947 # 4948 if( istRFKorr ) : 4949 # return None 4950 return sprUebvarId 4951 else : 4952 if( sprUebvarId == None ) : 4953 return tmpRW 4954 4955 else: 4956 return spr_uebvar_id__neu

4957 4958 4959 4960 4961 # 4962 # ------------------------------------------------------------------------------------ 4963 # -- In Tabelle >prj.p_strverbindung< schreiben -------------------------- 4964 # ------------------------------------------------------------------------------------ 4965 #

4966 - def schreibe__prjPStrverbindung( self, prjProjekteId, strStrktIdVorg, strStrktIdNachf, fbtor, notizen ):

4967 """ 4968 Methode zum Einfügen / Aktualisieren projektspezifischer Informationen in die / der Datenbanktabelle C{prj.pp_strstrkt}. 4969 4970 @param prjProjekteId : Es ist die Projekt-Id C{prj.projekte.id} zu übergeben. 4971 @type prjProjekteId : C{Ganzzahl} 4972 4973 @param strStrktIdVorg : Es ist die Struktur-Id C{str.strkt.id} des ersten (linken) Strukturpunktes zu übergeben. 4974 @type strStrktIdVorg : C{Ganzzahl} 4975 4976 @param strStrktIdNachf : Es ist die Struktur-Id C{str.strkt.id} des nachfolgenden (mit dem linken verbndenen) Strukturpunkt zu übergeben. 4977 @type strStrktIdNachf : C{Ganzzahl} 4978 4979 @param fbtor : -- Noch nicht implementiert -- : Es ist das Fehlerbaumtor zu übergeben 4980 @type fbtor : C{Zeichenkette} 4981 4982 @param notizen : -- Noch nicht implementiert -- : Es sind die Notizen zu übergeben. 4983 @type notizen : C{Zeichenkette} 4984 """ 4985 4986 # 4987 # -- 4988 # -- Verbindung zwischen den Strukturpunkten herstellen ------------------ 4989 # -- ---------- 4990 # -- prj.nimm__tabwerte( 'p_strverbindung', ARRAY[ ---------- 4991 # -- 1. prj_projekte_id ---------- 4992 # -- 2. str_strkt_id_vorg ---------- 4993 # -- 3. str_strkt_id_nachf ---------- 4994 # -- 4. fbtor ---------- 4995 # -- 5. notizen ] ) ---------- 4996 # -- ---------- 4997 # -- -------------------------------------------------------------------------- 4998 # 4999 self.__dbAbfrage__( """ 5000 SELECT * FROM prj.nimm__tabwerte( 'p_strverbindung', ARRAY[""" 5001 # 5002 # -- prj_projekte_id ---------------------------------- 5003 # 5004 + "'" + str( prjProjekteId ) + "'" 5005 # 5006 # -- str_strkt_id_vorg ---------------------------------- 5007 # 5008 + ", '" + str( strStrktIdVorg ) + "'" 5009 # 5010 # -- str_strkt_id_nachf ---------------------------------- 5011 # 5012 + ", '" + str( strStrktIdNachf ) + "']);" )

5013 5014 5015 5016 5017 5018 # 5019 # ------------------------------------------------------------------------------------ 5020 # -- Übersetzungsvariante übernehmen ---------------------------------- 5021 # ------------------------------------------------------------------------------------ 5022 #

5023 - def schreibe__sprUebvar( self, ListBoxErg, sprUebvarId, istMehrfachVerw ):

5024 """ 5025 Methode zum Schreiben von Übersetzungsvarianten. 5026 5027 5028 @param ListBoxErg: Es ist die C{ListBoxErg} zu übergeben, die die zu schreibenden Übersetzungen enthält. 5029 @type ListBoxErg: ListBoxErg 5030 5031 @param sprUebvarId : Es ist die Datenbankidentifikationsnummer (C{spr.uebvar.id}) der Übersetzungsvariante zu übergeben. 5032 @type sprUebvarId : C{Ganzzahl} 5033 5034 @param istMehrfachVerw: Die Übersetzungsvariante (C{spr.uebvar.id}) wird mehrfach verwendet. 5035 @type istMehrfachVerw: Boolean 5036 5037 @return: Es wird die ggf. neu erzeugte spr.uebvar.id zurückgegeben. 5038 @rtype: Ganzzahl 5039 """ 5040 5041 # 5042 # -- Hilfsübersetzung einfügen ------------------------------------------ 5043 # -- ---------- 5044 # -- Es wird zur >spr.uebvar.id == spr_uebvar_id__akt< in der ---------- 5045 # -- Sprache >spr.sprachen.id == 0 < (die nicht in der Projekt- ---------- 5046 # -- arbeit verwendet werden soll) eine Hilfsübersetzung ---------- 5047 # -- eingefügt ---------- 5048 # -- ---------- 5049 # -- ---------- 5050 # -- -------------------------------------------------------------------------- 5051 # 5052 spr_uebvar_id__akt = sprUebvarId 5053 5054 if( istMehrfachVerw ) : 5055 5056 self.__dbAbfrage__( """ 5057 -- 5058 -- Hilfsübersetzung einfügen 5059 -- 5060 SELECT spr.nimm__wgruppe( 'beliebige Zeichenkette', '0', '0' ) 5061 ;""" ) 5062 5063 spr_uebvar_id__akt = self.__gibWert__( 0, 0 ) 5064 5065 else : 5066 5067 self.__dbAbfrage__( """ 5068 -- 5069 -- Hilfsübersetzung einfügen 5070 -- 5071 SELECT spr.nimm__wgruppe( 'beliebige Zeichenkette', '0', '""" 5072 + str( spr_uebvar_id__akt ) + """' ); 5073 ;""" ) 5074 5075 5076 5077 # 5078 # -- Keine Mehrfachverwendung der Übersetzungsvariante ------------------ 5079 # -- ---------- 5080 # -- Die aktuellen Übersetzungen innerhalb der zu korrigierenden ---------- 5081 # -- Übersetzungsvariante löschen (somit läßt sich leicht mittels ---------- 5082 # -- >spr.nimm__wgruppe(...)< die Korrektur durchführen ---------- 5083 # -- ---------- 5084 # -- ---------- 5085 # -- -------------------------------------------------------------------------- 5086 # 5087 if( not istMehrfachVerw ) : 5088 5089 self.__dbAbfrage__( """ 5090 -- 5091 -- Alle Übersetzungen löschen 5092 -- 5093 SELECT intern.loesche__zeile( 'spr.uebersetzung' 5094 , 'spr.uebersetzung.spr_uebvar_id = """ + str( spr_uebvar_id__akt ) + """ 5095 AND spr_sprachen_id > 0' 5096 , 'true' );""" ) 5097 5098 5099 5100 # 5101 # -- Übersetzungsvarianten einlesen ------------------------------------------ 5102 # -- ---------- 5103 # -- ---------- 5104 # -- -------------------------------------------------------------------------- 5105 # 5106 for i in range( ListBoxErg.GetCount() ) : 5107 5108 self.__dbAbfrage__( """ 5109 -- 5110 -- Übersetzungsvariante übernehmen 5111 -- 5112 SELECT spr.nimm__wgruppe( '""" + ListBoxErg.gibWert( i ).encode('utf-8') + """' 5113 , '""" + str( ListBoxErg.gibClientData( i )[0] ) + """' 5114 , '""" + str( spr_uebvar_id__akt ) + """' ) 5115 ;""" ) 5116 5117 5118 5119 # 5120 # -- Hilfsübersetzung entfernen ------------------------------------------ 5121 # -- ---------- 5122 # -- ---------- 5123 # -- -------------------------------------------------------------------------- 5124 # 5125 self.__dbAbfrage__( """ 5126 -- 5127 -- Hilfsübersetzung löschen 5128 -- 5129 SELECT intern.loesche__zeile( 'spr.uebersetzung' 5130 , 'spr.uebersetzung.spr_uebvar_id = """ + str( spr_uebvar_id__akt ) + """ 5131 AND spr_sprachen_id = 0' 5132 , 'true' );""" ) 5133 5134 5135 5136 # 5137 # -- aktuelle >spr.uebvar.id< zurückgeben ---------------------------------- 5138 # 5139 return spr_uebvar_id__akt

5140 5141 5142 5143 5144 # 5145 # ------------------------------------------------------------------------------------ 5146 # -- Zugeordnete Dokumente selektieren ---------------------------------- 5147 # -- Sicht >prj.zeige__dokdoku< selektieren ---------------------------------- 5148 # ------------------------------------------------------------------------------------ 5149 #

5150 - def selektiere__prjPrtDoku( self, SiAnfStrktDok, prjProjekteId, sprSprachenId, prtProtokollId, psGefszenarioId, internFirmaId ):

5151 """ 5152 Methode zur arstellung der Dokumente, die einem Protokolleintrag, einer Sicherheitsanforderung, Terminplaneintrag zugeordnet sind. 5153 5154 @note: Die übergebene Auswahlliste (C{SiAnfStrktDok}) wird verändert ! 5155 5156 @param SiAnfStrktDok: Es ist das Listenobjekt zu übergeben, welches die Dokumente aufnimmt. 5157 @type SiAnfStrktDok: wxPython - SiAnfStrktDok 5158 5159 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 5160 @type prjProjekteId: Ganzzahl 5161 5162 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 5163 @type sprSprachenId: Ganzzahl 5164 5165 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 5166 @type prtProtokollId: Ganzzahl 5167 5168 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 5169 @type psGefszenarioId: Ganzzahl 5170 5171 @param internFirmaId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 5172 @type internFirmaId: Ganzzahl 5173 """ 5174 5175 # 5176 # -- SQL-Abfrage ausführen -------------------------------------------------- 5177 # 5178 self.__dbAbfrage__( self.gibSQL_prjPrtDoku( prjProjekteId = prjProjekteId 5179 , sprSprachenId = sprSprachenId 5180 , prtProtokollId = prtProtokollId 5181 , psGefszenarioId = psGefszenarioId 5182 , internFirmaId = internFirmaId ) ) 5183 5184 5185 # 5186 # -- Alle Einträge löschen, wenn nicht die Dokumente angezeigt ---------- 5187 # -- werden sollen, die den Protokolleinträgen zugeordnet sind ---------- 5188 # -- (dort wird das >SiAnfStrktDok.TreeCtrlErg__Id< von ---------- 5189 # -- >selektiere__psPrtStrkt()< gelöscht ---------- 5190 # 5191 if( prtProtokollId is None ) : 5192 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.loescheBaum() 5193 5194 5195 # 5196 # -- Werte übernehmen -------------------------------------------------- 5197 # 5198 if( self.__gibAnzZeilen__() > 0 ) : 5199 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.nimmWert( wert = 'Dok', wertId = 0, dbId = 0 ) 5200 5201 for i in range( self.__gibAnzZeilen__() ): 5202 5203 # 5204 # -- Dokumentinformationen ------------------------------------------ 5205 # 5206 aspekt = 'B: ' 5207 rev = '---' 5208 datum = '---' 5209 doknr = '---' 5210 if( self.__gibWert__( i, 8 ) == 'QUELLE' ) : aspekt = 'Q: ' 5211 if( len( self.__gibWert__( i, 5 ) ) > 0 ) : rev = self.__gibWert__( i, 5 ) 5212 if( len( str( self.__gibWert__( i, 6 ) ) ) > 0 ) : datum = self.__gibWert__( i, 6 ) 5213 if( len( self.__gibWert__( i, 2 ) ) > 0 ) : doknr = self.__gibWert__( i, 2 ) 5214 5215 dokinfo = ( aspekt 5216 + self.__gibWert__( i, 3 ) 5217 + '\t>' + self.__gibWert__( i, 9 ) 5218 + '<\t[Rev.: ' + rev 5219 + '\tDatum: ' + str( datum ) 5220 + '\tDok-Nr: ' + doknr 5221 + ']' ) 5222 5223 5224 # 5225 # -- Notizen -------------------------------------------------- 5226 # 5227 notizen = ( self.__gibWert__( i, 1 ) 5228 + '\t|\t' + self.__gibWert__( i, 4 ) ) 5229 5230 5231 # 5232 # -- Dokument-Id -------------------------------------------------- 5233 # 5234 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.nimmWert( wert = zk.gibIdWertNotizen( 5235 id = self.__gibWert__( i, 0 ) 5236 , zusInfo = "" 5237 , wert = dokinfo 5238 , notizen = notizen ) 5239 , wertId = self.__gibWert__( i, 0 ) 5240 , dbId = self.__gibWert__( i, 0 ) 5241 , wertIdVorgaenger = 0 5242 # 5243 # -- prj.pl_prtdokdoku.notizen 5244 # -- prj.pl_prtdokdoku.nr 5245 # -- prj.pl_prtdokdoku.spr_uebvar_id 5246 # -- prj.pl_prtdokdoku.spr_uebvar_id_zus 5247 # -- 5248 # -- prj.pl_dokausgabe.notizen 5249 # -- prj.pl_dokausgabe.datum 5250 # -- prj.pl_dokausgabe.istfrei 5251 # -- prj.pl_dokausgabe.stand 5252 # -- 5253 # -- dok__doku__aspekt 5254 # 5255 , clientData = [ self.__gibWert__( i, 4 ) 5256 , self.__gibWert__( i, 2 ) 5257 , self.__gibWert__( i, 10 ) 5258 , self.__gibWert__( i, 11 ) 5259 , self.__gibWert__( i, 7 ) 5260 , self.__gibWert__( i, 6 ) 5261 , self.__gibWert__( i, 12 ) 5262 , self.__gibWert__( i, 5 ) 5263 , self.__gibWert__( i, 8 )] ) 5264 5265 5266 # 5267 # -- Baum anzeigen, ersten Eintrag auswählen -------------------------- 5268 # 5269 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.erzeugeBaum() 5270 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.markiereWert()

5271 5272 5273 5274 5275 5276 # 5277 # ------------------------------------------------------------------------------------ 5278 # -- die ausgewählten Einträge in >wxComboBox<, -------------------------- 5279 # -- Sicht >prj.zeige__pl_psgefabk< selektieren -------------------------- 5280 # ------------------------------------------------------------------------------------ 5281 #

5282 - def selektiere__psGefAbk( self, LBGefSpWTALPersonen, CBHaeufig, LBHaeufigBegr, CBGefStufe, LBGefStufeBegr, TCASRisikoStufe, LBRisikoStufeBegr, prjProjekteId, sprSprachenId, psGefszenarioId ):

5283 """ 5284 Methode zur Auswahl der Abkürzung in der Auswahlliste (C{wxComboBox}. 5285 5286 @note: Die übergebene Auswahlliste (C{wxComboBox}) wird verändert ! 5287 5288 @requires: Mittels C{initwxControlWithItems_psAbk(...)} müssen C{LBGefPersonen, CBHaeufig, CBGefStufe, TCASRisikoStufe} mit gültigen Werten gefüllt werden. 5289 5290 5291 @param LBGefSpWTALPersonen: Es ist die Auswahlliste zu übergeben, die die gefährdeten Personen aufnimmt. 5292 @type LBGefSpWTALPersonen: wxPython - ListBoxSpWTitelAL 5293 @param CBHaeufig: Es ist die Auswahlliste zu übergeben, die die Häufigkeit aufnimmt. 5294 @type CBHaeufig: wxPython - wxComboBox 5295 @param LBHaeufigBegr: Es sind die Texteingabefelder zu übergeben, die die Begründung / internen Notizen zur Häufigkeit aufnehmen. 5296 @type LBHaeufigBegr: wxPython - TextCtrlSpWTitel 5297 @param CBGefStufe: Es ist die Auswahlliste zu übergeben, die die Gefahrenstufe aufnimmt. 5298 @type CBGefStufe: wxPython - wxComboBox 5299 @param LBGefStufeBegr: Es sind die Texteingabefelder zu übergeben, die die Begründung / internen Notizen zur Gefahrenstufe aufnehmen. 5300 @type LBGefStufeBegr: wxPython - TextCtrlSpWTitel 5301 @param TCASRisikoStufe: Es ist die Auswahlliste zu übergeben, die die Risikostufen aufnimmt. 5302 @type TCASRisikoStufe: TextCtrlAuswStatisch 5303 @param LBRisikoStufeBegr: Es sind die Texteingabefelder zu übergeben, die die Bewertung / internen Notizen der Risikostufe aufnehmen. 5304 @type LBRisikoStufeBegr: wxPython - TextCtrlSpWTitel 5305 5306 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 5307 @type prjProjekteId: Ganzzahl 5308 5309 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 5310 @type sprSprachenId: Ganzzahl 5311 5312 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 5313 @type psGefszenarioId: Ganzzahl 5314 """ 5315 5316 # 5317 # -- SQL-Abfrage ausführen -------------------------------------------------- 5318 # 5319 self.__dbAbfrage__( self.gibSQL_prjPlPsGefabk( prjProjekteId = prjProjekteId 5320 , sprSprachenId = sprSprachenId 5321 , psGefszenarioId = psGefszenarioId ) ) 5322 5323 5324 5325 5326 5327 # 5328 # -- >LBGefSpWTALPersonen<, >CBHaeufig<, >CBGefStufe<, ------------------ 5329 # -- >TCASRisikoStufe< --- Selektionen zurücksetzen ------------------ 5330 # -- >LBHaeufigBegr<, >LBGefStufeBegr<, ------------------ 5331 # -- >LBRisikoStufeBegr< --- alte Einträge löschen ------------------ 5332 # 5333 LBGefSpWTALPersonen.schiebeAlleRechts() 5334 del LBGefSpWTALPersonen.ListBox__li.clientData[:] 5335 5336 CBHaeufig.SetSelection( 0 ) 5337 LBHaeufigBegr.loescheAlles() 5338 5339 CBGefStufe.SetSelection( 0 ) 5340 LBGefStufeBegr.loescheAlles() 5341 5342 TCASRisikoStufe.setzeWert( 0 ) 5343 LBRisikoStufeBegr.loescheAlles() 5344 5345 5346 5347 # 5348 # -- Selektionen setzen -------------------------------------------------- 5349 # 5350 # GP ... gefährdete Personen 5351 # RH ... Risikobewertung Häufigkeit 5352 # RG ... Risikobewertung Gefahrenstufe 5353 # RR ... Risikobewertung Risikostufe 5354 # 5355 for i in range( self.__gibAnzZeilen__() ): 5356 typ = self.__gibWert__( i, 0 ) 5357 5358 # 5359 # -- gefährdete Personen -------------------------- 5360 # -- (es werden mehrere Werte gesetzt) -------------------------- 5361 # 5362 if typ == 'GP': 5363 5364 LBGefSpWTALPersonen.schiebeLinks( self.__gibWert__( i, 1 ) ) 5365 5366 # 5367 # -- Abk-Id speichern, um Stand vor der Benutzeränderung zu erfassen 5368 # 5369 LBGefSpWTALPersonen.ListBox__li.clientData.append( self.__gibWert__( i, 1 ) ) 5370 5371 continue 5372 5373 5374 # 5375 # -- 1.) Risikobewertung Häufigkeit (im GUI angezeigt) -- 5376 # -- Notizen zur Häufigkeit (im GUI angezeigt) -- 5377 # -- -- 5378 # -- Es wird nur ein Wert gesetzt ! -- 5379 # 5380 if typ == 'RH': 5381 5382 for k in range( CBHaeufig.GetCount() ) : 5383 if( CBHaeufig.gibClientData( selection = k, lfdNr = 0 ) == self.__gibWert__( i, 1 ) ) : 5384 break 5385 5386 CBHaeufig.SetSelection( k ) 5387 5388 LBHaeufigBegr.nimmWert( wert = self.__gibWert__( i, 2 ) + '\t|\t' + self.__gibWert__( i, 3 ) 5389 , clientData = [ self.__gibWert__( i, 4 ) 5390 # -- >notizen< ------------------------- 5391 , self.__gibWert__( i, 3 ) ] ) 5392 LBHaeufigBegr.SetSelection( 0 ) 5393 5394 continue 5395 5396 5397 # 5398 # -- 1.) Risikobewertung Gefahrenstufe (im GUI angezeigt) -- 5399 # -- Notizen zur Gefahrenstufe (im GUI angezeigt) -- 5400 # -- -- 5401 # -- Es wird nur ein Wert gesetzt ! -- 5402 # 5403 if typ == 'RG': 5404 5405 for k in range( CBGefStufe.GetCount() ) : 5406 5407 if( CBGefStufe.gibClientData( selection = k, lfdNr = 0 ) == self.__gibWert__( i, 1 ) ): 5408 break 5409 5410 CBGefStufe.SetSelection( k ) 5411 5412 LBGefStufeBegr.nimmWert( wert = self.__gibWert__( i, 2 ) + '\t|\t' + self.__gibWert__( i, 3 ) 5413 , clientData = [ self.__gibWert__( i, 4 ) 5414 # -- >notizen< ------------------------- 5415 , self.__gibWert__( i, 3 ) ] ) 5416 LBGefStufeBegr.SetSelection( 0 ) 5417 5418 continue 5419 5420 5421 # 5422 # -- 1.) Risikobewertung Risikostufe (im GUI angezeigt) -- 5423 # -- Notizen zur Risikostufe (im GUI angezeigt) -- 5424 # -- -- 5425 # -- Es wird nur ein Wert gesetzt ! -- 5426 # 5427 if typ == 'RR': 5428 5429 for k in range( TCASRisikoStufe.gibAnzahl() ) : 5430 if( TCASRisikoStufe.gibClientData( k )[0] == self.__gibWert__( i, 1 ) ): 5431 break 5432 5433 TCASRisikoStufe.setzeWert( k ) 5434 5435 LBRisikoStufeBegr.nimmWert( wert = self.__gibWert__( i, 2 ) + '\t|\t' + self.__gibWert__( i, 3 ) 5436 , clientData = [ self.__gibWert__( i, 4 ) 5437 # -- >notizen< ------------------------- 5438 , self.__gibWert__( i, 3 ) ] ) 5439 LBRisikoStufeBegr.SetSelection( 0 ) 5440 5441 continue

5442 5443 5444 5445 5446 # 5447 # ------------------------------------------------------------------------------------ 5448 # -- die ausgewählten Einträge in >ListBoxSpWTitelSync<, ------------------ 5449 # -- Sicht >prj.zeige__pl_psgefanm< selektieren ------------------ 5450 # ------------------------------------------------------------------------------------ 5451 #

5452 - def selektiere__psGefAnm( self, ListBoxGefAnm, TreeCtrlErgAnmId, ListBoxErgVorhAnmId, liesAlles, prjProjekteId, sprSprachenId, psGefszenarioId, psAnmerkungId ):

5453 """ 5454 Methode zum Eintragen der Anmerkungen zum Gefahrenszenario in der Risikoanalyse bzw. im Formular zum Bearbieten der Anmerkungen. 5455 5456 @note: Die in C{ListBoxGefAnm} enthaltenen Auswahllisten werden verändert ! 5457 5458 @param ListBoxGefAnm: Es ist die Auswahlliste zu übergeben, die die Anmerkungen in der Risikoanalyse aufnehnmen soll (C{ListBoxErgVorhAnmId = None, TCSpWTitel = None}). 5459 @type ListBoxGefAnm: wxPython - ListBoxGefAnm 5460 5461 @param TreeCtrlErgAnmId: Es ist die Auswahlliste zu übergeben, die die Anmerkungen-Id im Formular zum Bearbeiten der Anmerkungen aufnehnmen soll (C{ListBoxGefAnm = None, TCSpWTitel = None}). 5462 @type TreeCtrlErgAnmId: ListBoxErg 5463 5464 @param ListBoxErgVorhAnmId: Es ist die Auswahlliste zu übergeben, die die Id der vorhandenen Anmerkungen im Formular zum Bearbeiten der Anmerkungen aufnehnmen soll (C{ListBoxGefAnm = None, TCSpWTitel = None}). 5465 @type ListBoxErgVorhAnmId: ListBoxErg 5466 5467 @param liesAlles: Nur für C{ListBoxErgVorhAnmId} gültig ! Wenn C{True} angegeben ist werden alle in der Datenbank vorhandenen Anmerkungen übernommen. Wenn C{False} angegeben ist werden alle zum Gefahrenszenario C{psGefszenarioId} vorhandenen Anmerkungen übernommen. 5468 @type liesAlles: Boolean 5469 5470 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 5471 @type prjProjekteId: Ganzzahl 5472 5473 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 5474 @type sprSprachenId: Ganzzahl 5475 5476 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 5477 @type psGefszenarioId: Ganzzahl 5478 5479 @param psAnmerkungId : Es ist die Datenbankidentifikationsnummer (C{ps.anmerkung.id}) der aktuellen Anmerkung zu übergeben. 5480 @type psAnmerkungId : Ganzzahl 5481 """ 5482 5483 # 5484 # -- universeller Teil der SQL-Abfrage ---------------------------------- 5485 # 5486 sql = ( """ 5487 -- 5488 -- Anmerkungen - es wird der jeweils letzte zugeordnete Eintrag angezeigt 5489 -- (Logbuchfunktion) 5490 -- 5491 SELECT DISTINCT 5492 -- 0 5493 spr.zeige__wgruppe.wgruppe AS zk 5494 , prj.zeige__pl_psgefanm.notizen 5495 -- 2 5496 , prj.zeige__pl_psgefanm.spr_uebvar_id 5497 , prj.zeige__pl_psgefanm.ps_anmerkung_id AS anmerkung_id 5498 -- 5499 -- Kontrolle 5500 -- 5501 --, prj.zeige__pl_psgefanm.spr_uebvar_id AS spr_uebvar_id 5502 --, prj.zeige__pl_psgefanm.logdatuhrz AS datuhrz 5503 FROM 5504 prj.zeige__pl_psgefanm_le 5505 , prj.zeige__pl_psgefanm 5506 , spr.zeige__wgruppe 5507 WHERE 5508 -- 5509 -- Zeichenketten ausgeben 5510 -- 5511 prj.zeige__pl_psgefanm.spr_uebvar_id = 5512 spr.zeige__wgruppe.spr_uebvar_id 5513 AND 5514 -- 5515 -- Sprache auswählen 5516 -- 5517 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ 5518 AND 5519 -- 5520 -- Ausschließlich die letzten (aktuellen) Anmerkungen anzeigen, ... 5521 -- 5522 prj.zeige__pl_psgefanm_le.prj__pl_psgefanm__id = 5523 prj.zeige__pl_psgefanm.id""" ) 5524 5525 5526 # 5527 # -- Risikoanalyse -- 5528 # -- Formular zum Bearbeiten der Anmerkungen ('Anmerkungen/Int. Notizen') -- 5529 # 5530 # if( ListBoxGefAnm != None or TreeCtrlErgAnmId != None or TCSpWTitel != None ) : 5531 if( ListBoxGefAnm != None or TreeCtrlErgAnmId != None ) : 5532 sql = sql + ( """ 5533 AND 5534 -- 5535 -- ... die nicht entfernt wurden 5536 -- 5537 prj.zeige__pl_psgefanm.logentfernt = false 5538 AND 5539 -- 5540 -- Projekt auswählen 5541 -- 5542 prj.zeige__pl_psgefanm.prj_projekte_id = """ 5543 + str( prjProjekteId ) + """ 5544 AND 5545 -- 5546 -- Gefahrenszenario auswählen 5547 -- 5548 prj.zeige__pl_psgefanm.ps_gefszenario_id = """ 5549 + str( psGefszenarioId ) ) 5550 5551 # 5552 # -- Formular zum Bearbeiten der Anmerkungen ('Anmerkungen/Int. Notizen') 5553 # 5554 # if( TCSpWTitel != None ) : 5555 # sql = sql + ( """ 5556 # AND 5557 # -- 5558 # -- Anmerkung auswählen 5559 # -- 5560 # prj.zeige__pl_psgefanm.ps_anmerkung_id = """ 5561 # + str( psAnmerkungId ) ) 5562 5563 # 5564 # -- SQL-Abfrage abschließen 5565 # 5566 sql = sql + ";" 5567 5568 5569 5570 # 5571 # -- Formular zum Bearbeiten der Anmerkungen ('Vorh. Anmerkungen') ---------- 5572 # 5573 else : 5574 # 5575 # -- Die Anmerkungen zum Gefahrenszenario anzeigen ------------------ 5576 # 5577 tmp = "" 5578 if( not liesAlles ) : 5579 tmp = ( """ 5580 AND 5581 -- 5582 -- Gefahrenszenario auswählen 5583 -- 5584 prj.zeige__pl_psgefanm.ps_gefszenario_id = """ 5585 + str( psGefszenarioId ) ) 5586 5587 # 5588 # -- SQL-Abfrage zusammenbauen ---------------------------------- 5589 # 5590 sql = sql + ( """ 5591 AND 5592 -- 5593 -- keine Null-Anmerkungen zeigen 5594 -- 5595 prj.zeige__pl_psgefanm.id > 0""" 5596 + tmp 5597 + """ 5598 5599 -- 5600 -- alle Anmerkungen entfernen die dem Gefahrenszenario projektspezifisch zugeordnet sind 5601 -- 5602 EXCEPT 5603 5604 """ 5605 + sql + """ 5606 AND 5607 -- 5608 -- ... die nicht entfernt wurden 5609 -- 5610 prj.zeige__pl_psgefanm.logentfernt = false 5611 AND 5612 -- 5613 -- Projekt auswählen 5614 -- 5615 prj.zeige__pl_psgefanm.prj_projekte_id = """ 5616 + str( prjProjekteId ) + """ 5617 AND 5618 -- 5619 -- Gefahrenszenario auswählen 5620 -- 5621 prj.zeige__pl_psgefanm.ps_gefszenario_id = """ 5622 + str( psGefszenarioId ) 5623 + ";" ) 5624 5625 5626 # 5627 # -- Datenbankabfrage ausführen ------------------------------------------ 5628 # 5629 self.__dbAbfrage__( sql ) 5630 5631 5632 5633 # 5634 # -- Anmerkungen / Notizen löschen ------------------------------------------ 5635 # -- (Risikoanalyse) ------------------------------------------ 5636 # 5637 if( ListBoxGefAnm != None ) : 5638 # ListBoxGefAnm.ListBox__li.loescheAlles() 5639 # ListBoxGefAnm.ListBox__re.loescheAlles() 5640 ListBoxGefAnm.loescheAlles() 5641 5642 # 5643 # -- Anmerkungen / Notizen löschen ------------------------------------------ 5644 # -- Formular zum Bearbeiten der Anmerkungen ---------------------------------- 5645 # 5646 # elif( TCSpWTitel != None ) : 5647 # TCSpWTitel.TextCtrl__li.nimmWert( wert = zk.gibZk( "" ) ) 5648 # TCSpWTitel.TextCtrl__re.nimmWert( wert = zk.gibZk( "" ) ) 5649 5650 # 5651 # -- Liste der Anmerkungen-Id löschen ---------------------------------- 5652 # 5653 elif( TreeCtrlErgAnmId != None ) : 5654 TreeCtrlErgAnmId.loescheBaum() 5655 5656 5657 # 5658 # -- Liste der vorhandenen Anmerkungen löschen -------------------------- 5659 # -- Formular zum Bearbeiten der Anmerkungen -------------------------- 5660 # 5661 else : 5662 ListBoxErgVorhAnmId.loescheAlles() 5663 # ListBoxSpWTSVorhAnm.ListBox__li.loescheAlles() 5664 # ListBoxSpWTSVorhAnm.ListBox__re.loescheAlles() 5665 5666 5667 # 5668 # -- Anmerkungen (im GUI angezeigt) -------------------------- 5669 # -- Notizen zu den Anmerkungen (im GUI angezeigt) -------------------------- 5670 # -- (Risikoanalyse) -------------------------- 5671 # 5672 if( ListBoxGefAnm != None ) : 5673 5674 for i in range( self.__gibAnzZeilen__() ): 5675 5676 ListBoxGefAnm.nimmWert( wert = zk.gibIdWertNotizen( id = self.__gibWert__( i, 3 ) 5677 , zusInfo = "" 5678 , wert = self.__gibWert__( i, 0 ) 5679 , notizen = self.__gibWert__( i, 1 ) ) 5680 , clientData = [ # -- spr.uebvar.id --------------------- 5681 self.__gibWert__( i, 2 ) 5682 # -- notizen --------------------------- 5683 , self.__gibWert__( i, 1 ) 5684 # -- ps.anmerkung.id ------------------- 5685 , self.__gibWert__( i, 3 ) 5686 # -- anmerkung ------------------------- 5687 , self.__gibWert__( i, 0 ) ] ) 5688 5689 5690 # ListBoxGefAnm.ListBox__li.nimmWert( wert = str( self.__gibWert__( i, 0 ) ) 5691 # , clientData = [ self.__gibWert__( i, 3 ) 5692 # , self.__gibWert__( i, 2 ) ] ) 5693 # 5694 # ListBoxGefAnm.ListBox__re.nimmWert( wert = str( self.__gibWert__( i, 1 ) ) ) 5695 5696 # 5697 # -- Anmerkungen / Notizen übernehmen ---------------------------------- 5698 # -- Formular zum Bearbeiten der Anmerkungen ---------------------------------- 5699 # 5700 # elif( TCSpWTitel != None ) : 5701 # TCSpWTitel.TextCtrl__li.nimmWert( 5702 # wert = self.__gibWert__( 0, 0 ) 5703 # , clientData = self.__gibWert__( 0, 2 ) ) 5704 # 5705 # TCSpWTitel.TextCtrl__re.nimmWert( wert = self.__gibWert__( 0, 1 ) ) 5706 5707 # 5708 # -- Liste der Anmerkungen-Id übernehmen ---------------------------------- 5709 # 5710 elif( TreeCtrlErgAnmId != None ) : 5711 5712 for i in range( self.__gibAnzZeilen__() ): 5713 5714 # TreeCtrlErgAnmId.nimmWert( wert = str( self.__gibWert__( i, 3 ) ) 5715 # , clientData = [ None 5716 # , str( self.__gibWert__( i, 0 ) ) ] ) 5717 5718 5719 # TreeCtrlErg.nimmWert( wert = zk.gibIdWertNotizen( id = posInWerte[i] 5720 # , zusInfo = txtTechnSiAnf 5721 # , wert = werte[i][1] 5722 # , notizen = werte[i][2] ) 5723 # , wertId = ( i + 1 ) 5724 # , dbId = posInWerte[i] 5725 # , wertIdVorgaenger = wertIdVorg 5726 # , clientData = [ werte[i][3] 5727 # , werte[i][4] 5728 # , werte[i][2]] 5729 ## # -- wird für die Bearbeitung der >spr_uebvar_id< benötigt 5730 ## , 'prj.pp_prtprotokoll'] 5731 # ) 5732 5733 5734 TreeCtrlErgAnmId.nimmWert( wert = zk.gibIdWertNotizen( id = self.__gibWert__( i, 3 ) 5735 , zusInfo = "" 5736 , wert = self.__gibWert__( i, 0 ) 5737 , notizen = self.__gibWert__( i, 1 ) ) 5738 , wertId = ( i + 1 ) 5739 # -- ps.anmerkung.id -------------------------- 5740 , dbId = self.__gibWert__( i, 3 ) 5741 , wertIdVorgaenger = None 5742 , clientData = [ # -- spr.uebvar.id ----------- 5743 self.__gibWert__( i, 2 ) 5744 # -- notizen ----------------- 5745 , self.__gibWert__( i, 1 ) 5746 # -- ps.anmerkung.id --------- 5747 , self.__gibWert__( i, 3 ) 5748 # -- anmerkung --------------- 5749 , self.__gibWert__( i, 0 ) ] ) 5750 # 5751 # -- Baum anzeigen ---------------------------------------------------------- 5752 # 5753 TreeCtrlErgAnmId.erzeugeBaum() 5754 TreeCtrlErgAnmId.markiereWert() 5755 5756 5757 # 5758 # -- Liste der Vorhandenen Anmerkungen übernehmen -------------------------- 5759 # -- Formular zum Bearbeiten der Anmerkungen -------------------------- 5760 # 5761 else : 5762 5763 for i in range( self.__gibAnzZeilen__() ): 5764 5765 # ListBoxErgVorhAnmId.nimmWert( wert = str( self.__gibWert__( i, 3 ) ) ) 5766 5767 5768 ListBoxErgVorhAnmId.nimmWert( wert = zk.gibIdWertNotizen( id = self.__gibWert__( i, 3 ) 5769 , zusInfo = "" 5770 , wert = self.__gibWert__( i, 0 ) 5771 , notizen = self.__gibWert__( i, 1 ) ) 5772 , clientData = [ # -- spr.uebvar.id --------------------- 5773 self.__gibWert__( i, 2 ) 5774 # -- notizen --------------------------- 5775 , self.__gibWert__( i, 1 ) 5776 # -- ps.anmerkung.id ------------------- 5777 , self.__gibWert__( i, 3 ) 5778 # -- anmerkung ------------------------- 5779 , self.__gibWert__( i, 0 ) ] )

5780 5781 5782 5783 # ListBoxSpWTSVorhAnm.ListBox__li.nimmWert( wert = str( self.__gibWert__( i, 0 ) ) ) 5784 # ListBoxSpWTSVorhAnm.ListBox__re.nimmWert( wert = str( self.__gibWert__( i, 1 ) ) ) 5785 5786 5787 5788 5789 # 5790 # ------------------------------------------------------------------------------------ 5791 # -- die ausgelesenen Einträge in >ListBoxSpWTitelSync< bzw. ------------------ 5792 # -- >ListBoxSpWTitelUnabh< darstellen ------------------ 5793 # -- ------------------ 5794 # -- Sicht >prj.zeige__pl_prtpsgefszenario< auslesen ------------------ 5795 # ------------------------------------------------------------------------------------ 5796 #

5797 - def selektiere__psGefProt( self, LBSpWTU_SiAnf, TreeCtrlErg_Prot, SiAnfStrktDok, prjProjekteId, sprSprachenId, psGefszenarioId, aspekt ):

5798 """ 5799 Methode zum Eintragen der Sicherheitsanforderungen und Gefahrenprotokolleinträge. 5800 5801 @note: Die in (C{LBSpWTU_SiAnf, TreeCtrlErg_Prot}) enthaltenen Auswahllisten werden verändert ! 5802 5803 @param LBSpWTU_SiAnf: Es ist die Auswahlliste zu übergeben, die die Technischen und Organisatorischen Maßnahmen zur Risikominderung aufnehnmen soll. 5804 @type LBSpWTU_SiAnf: wxPython - ListBoxSpWTitelUnabh 5805 5806 @param TreeCtrlErg_Prot: Es ist die Baumstruktur zu übergeben, die die Gefahrenprotokolleinträge aufnehnmen soll. 5807 @type TreeCtrlErg_Prot: TreeCtrlErg 5808 5809 @param SiAnfStrktDok: Es ist das Listenobjekt zu übergeben, welches die Sicherheitsanforderungen-Id aufnimmt. 5810 @type SiAnfStrktDok: wxPython - SiAnfStrktDok 5811 5812 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 5813 @type prjProjekteId: Ganzzahl 5814 5815 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 5816 @type sprSprachenId: Ganzzahl 5817 5818 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 5819 @type psGefszenarioId: Ganzzahl 5820 5821 @param aspekt: Es ist der Aspekt (PE, SF, TP) des Protokolleintrages (C{prt.typ.aspekte}) zu übergeben. 5822 @type aspekt: Zeichenkette 5823 """ 5824 5825 # 5826 # -- Datenbankabfrage ausführen ------------------------------------------ 5827 # 5828 self.__dbAbfrage__( self.gibSQL_psPrtProtokoll( prjProjekteId = prjProjekteId 5829 , sprSprachenId = sprSprachenId 5830 , prtTypAspekt = aspekt 5831 , psGefszenarioId = psGefszenarioId ) ) 5832 5833 5834 # 5835 # -- Technische Maßnahmen, Dokumentationsanforderungen löschen ---------- 5836 # -- Organisatorische Maßnahmen (Betrieb + IH) löschen ---------- 5837 # -- Gefahrenprotokolleinträge löschen ---------- 5838 # -- Sicherheitsanforderungen-Id löschen ---------- 5839 # 5840 if( TreeCtrlErg_Prot is not None ) : TreeCtrlErg_Prot.loescheBaum() 5841 5842 if( LBSpWTU_SiAnf is not None ) : 5843 LBSpWTU_SiAnf.ListBox__li.loescheAlles() 5844 LBSpWTU_SiAnf.ListBox__re.loescheAlles() 5845 5846 if( SiAnfStrktDok is not None ) : 5847 SiAnfStrktDok.loescheBaum() 5848 5849 5850 # 5851 # -- Protokolleinträge eintragen ---------------------------------- 5852 # 5853 for i in range( self.__gibAnzZeilen__() ): 5854 5855 # 5856 # -- Gefahrenprotokolleinträge übernehmen ---------------------------------- 5857 # 5858 # -- Eine Unterscheidung der >prt.typ.id< ist nicht erfordelich ---------- 5859 # 5860 # 1 | 01: Frage 5861 # 2 | 01: Antwort 5862 # 3 | 01: Änderung 5863 # 4 | 01: Änderung abgestimmt mit dem Gutachter 5864 # 5 | 01: Änderung abgestimmt mit dem Kunden 5865 # 6 | 01: Änderung abgestimmt mit dem Experten 5866 # 7 | 02: Information 5867 # 8 | 02: Information aus einer Beratung 5868 # 9 | 02: Information vom Kunden 5869 # 10 | 02: Information vom Experten 5870 # 11 | 03: Sicherheitsüberprüfung erforderlich 5871 # 12 | 03: Sicherheitsüberprüfung mit dem Gutachter durchgeführt 5872 # 13 | 03: Sicherheitsüberprüfung mit dem Kunden durchgeführt 5873 # 14 | 03: Sicherheitsüberprüfung mit dem Experten durchgeführt 5874 # 15 | 04: Funktionsüberprüfung durchgeführt 5875 # 16 | 04: Funktionsüberprüfung erforderlich 5876 # 17 | 05: Ursprung des Gefahrenszenarios 5877 # 18 | 05: Ursprung der Sicherheitsanforderung 5878 # 19 | 05: Aktivitäten zum Gefahrenszenario abgeschlossen 5879 # 5880 if aspekt == 'PE': 5881 TreeCtrlErg_Prot.nimmWert( zk.gibIdWertNotizen( id = self.__gibWert__( i, 3 ) 5882 , zusInfo = "" 5883 , wert = self.__gibWert__( i, 2 ) 5884 , notizen = self.__gibWert__( i, 6 ) ) 5885 , wertId = self.__gibWert__( i, 3 ) 5886 , dbId = self.__gibWert__( i, 3 ) 5887 # ich brauche 'None', um den Baum zu bauen 5888 , wertIdVorgaenger = self.__dbAbfrage__Ergebnis[i][4] 5889 , clientData = [ # -- analog >selektiere__psPrtProtokoll()< 5890 # -- prj.pp_prtprotokoll.id --- 5891 self.__gibWert__( i, 7 ) 5892 # -- spr.uebvar.id --------------------- 5893 , self.__gibWert__( i, 5 ) 5894 # -- notizen --------------------------- 5895 , self.__gibWert__( i, 6 ) ] ) 5896 5897 5898 # 5899 # -- Sicherheitsanforderungen übernehmen ---------------------------------- 5900 # 5901 if aspekt == 'SF': 5902 clientData = [] 5903 typId = self.__gibWert__( i, 1 ) 5904 5905 # 5906 # -- Sicherheitsanforderungen-Id ---------------------------------- 5907 # 5908 if( SiAnfStrktDok is not None ) : 5909 SiAnfStrktDok.nimmWert( 5910 wert = str( self.__gibWert__( i, 3 ) ).zfill( 4 ) 5911 , wertId = self.__gibWert__( i, 3 ) ) 5912 5913 5914 # 5915 # -- 1.) Technische Maßnahmen (im GUI angezeigt) -- 5916 # 5917 # 20 | 01: Technische Maßnahme (Konstruktion) 5918 # 21 | 01: Technische Maßnahme (Sicherheitsfunktion) 5919 # 5920 if( ( typId == 20 or typId == 21 ) and LBSpWTU_SiAnf is not None ) : 5921 clientData.append( self.__gibWert__( i, 0 ) ) 5922 clientData.append( self.__gibWert__( i, 3 ) ) 5923 LBSpWTU_SiAnf.ListBox__li.nimmWert( wert = self.__gibWert__( i, 2 ) 5924 , clientData = clientData ) 5925 continue 5926 5927 # 5928 # -- 1.) Org. Maßnahmen, Anf. an Dokumentation / Prüfung (im GUI angezeigt) -- 5929 # 5930 # 22 | 01: Dokumentationsanforderung an den Fahrzeughersteller 5931 # 23 | 01: Vom Fahrzeughersteller durchzuführende Prüfung 5932 # 24 | 02: Während des Betriebseinsatzes durchzuführende Maßnahme 5933 # 25 | 02: In die Bedienungsanleitung aufzunehmende Anforderung 5934 # 26 | 03: Instandhaltungsmaßnahme 5935 # 27 | 03: In die Instandhaltungsdokumentation aufzunehmende Anforderung 5936 # 5937 if( ( typId == 22 or typId == 23 or typId == 24 or typId == 25 or typId == 26 or typId == 27 ) 5938 and LBSpWTU_SiAnf is not None ) : 5939 5940 clientData.append( self.__gibWert__( i, 0 ) ) 5941 clientData.append( self.__gibWert__( i, 3 ) ) 5942 LBSpWTU_SiAnf.ListBox__re.nimmWert( wert = self.__gibWert__( i, 2 ) 5943 , clientData = clientData ) 5944 continue 5945 5946 5947 # 5948 # -- Baum der Gefahrenprotokoll-Id bauen, vollständig anzeigen ---------- 5949 # -- und ersten Eintrag auswählen ---------- 5950 # 5951 if aspekt == 'PE': 5952 TreeCtrlErg_Prot.erzeugeBaum() 5953 TreeCtrlErg_Prot.markiereWert() 5954 5955 # TreeCtrlErg_Prot.ExpandAll() 5956 # eintrag = TreeCtrlErg_Prot.GetRootItem() 5957 # TreeCtrlErg_Prot.ScrollTo( eintrag ) 5958 # TreeCtrlErg_Prot.SelectItem( TreeCtrlErg_Prot.GetNextVisible( eintrag ) ) 5959 5960 5961 5962 # 5963 # -- Baum der Sicherheitsanforderungen-Id bauen, ------------------ 5964 # -- vollständig anzeigen und ersten Eintrag auswählen ------------------ 5965 # 5966 if( SiAnfStrktDok is not None ) : 5967 SiAnfStrktDok.erzeugeBaum() 5968 SiAnfStrktDok.markiereWert()

5969 5970 # SiAnfStrktDok.ExpandAll() 5971 # eintrag = SiAnfStrktDok.GetRootItem() 5972 # SiAnfStrktDok.ScrollTo( eintrag ) 5973 5974 5975 5976 5977 5978 5979 # 5980 # ------------------------------------------------------------------------------------ 5981 # -- die ausgewählten Einträge in >ListBoxSpWTitelAL<, ------------------ 5982 # -- Sicht >prj.zeige__pl_psgefstrkt< selektieren ------------------ 5983 # ------------------------------------------------------------------------------------ 5984 #

5985 - def selektiere__psGefStrkt( self, ListBoxSpWTitelAL, prjProjekteId, psGefszenarioId, strNameId ) :

5986 """ 5987 Methode zum Verschieben der Strukturpunkte aus der rechten Auswahlliste (C{ListBoxSpWTitelAL.ListBox__re} - verfügbare Strukturpunkte) in die linke Auswahlliste (C{ListBoxSpWTitelAL.ListBox__li} - verwendete Strukturpunkte). 5988 5989 @note: Die übergebenen Auswahllisten (C{ListBoxSpWTitelAL}) werden verändert ! 5990 5991 @requires: Mittels C{initWxListBox_strStrkt(...)} muß C{ListBoxSpWTitelAL.ListBox__re} mit gültigen Werten gefüllt werden. 5992 5993 @param ListBoxSpWTitelAL: Es ist die Auswahlliste zu übergeben, die die Abkürzungen enthält. 5994 @type ListBoxSpWTitelAL: wxPython - ListBoxSpWTitelAL 5995 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 5996 @type prjProjekteId: Ganzzahl 5997 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 5998 @type psGefszenarioId: Ganzzahl 5999 @param strNameId: Es ist die Datenbankidentifikationsnummer (C{str.name.id}) der Strukturbezeichnung zu übergeben 6000 @type strNameId: Ganzzahl 6001 """ 6002 6003 6004 # 6005 # -- Alle bisher ausgewählten Einträge nach rechts schieben ------------------ 6006 # 6007 ListBoxSpWTitelAL.schiebeAlleRechts() 6008 6009 6010 # 6011 # -- Strukturpunkte auslesen -------------------------------------------------- 6012 # 6013 str_strkt_id = self.gibListePsGefStrktId( prjProjekteId = prjProjekteId 6014 , psGefszenarioId = psGefszenarioId 6015 , strNameId = strNameId ) 6016 6017 6018 # 6019 # -- Einträge von rechts nach links verschieben -------------------------- 6020 # 6021 for i in range( len( str_strkt_id ) ): 6022 6023 ListBoxSpWTitelAL.schiebeLinks( str_strkt_id[i] )

6024 6025 6026 6027 # 6028 # ------------------------------------------------------------------------------------ 6029 # -- wxListBox der Tabelle 'ps.gefszenario' initialisieren ------------------ 6030 # ------------------------------------------------------------------------------------ 6031 #

6032 - def selektiere__psGefszenario( self, ListBoxGefSzen, ListBoxReprGefSzen, psGefszenarioId, prjProjekteId, sprSprachenId ):

6033 """ 6034 Methode zur Initialisierung der (C{wx Objekte}), welche den Ursprung, das Gefahrenszenario einschließlich Notizen und das repräsentative Gefahrenszenario gültig im aktuell übergebenen Projekt, dargestellt in der aktuell übergebenen Sprache zur aktuell gültigen Gefahrenszenario-Id aufnimmt (darstellt). 6035 6036 @note: Die übergebenen (C{wx Objekte}) werden verändert ! 6037 6038 @param ListBoxGefSzen: Es sind die Texteingabefelder zu übergeben, die das Gefahrenszenario / internen Notizen zum Gefahrenszenario aufnehmen. 6039 @type ListBoxGefSzen: wxPython - TextCtrlSpWTitel 6040 6041 @param ListBoxReprGefSzen: Es ist das Texteingabefeld zu übergeben, welches den Ursprung des Gefahrenszenarios aufnimmt. 6042 @type ListBoxReprGefSzen: wxPython - TextCtrl 6043 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 6044 @type psGefszenarioId: Ganzzahl 6045 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 6046 @type prjProjekteId: Ganzzahl 6047 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 6048 @type sprSprachenId: Ganzzahl 6049 """ 6050 6051 # 6052 # -- SQL-Abfrage ausführen -------------------------------------------------- 6053 # 6054 self.__dbAbfrage__( """ 6055 SELECT DISTINCT 6056 -- 0 6057 COALESCE( gefszen.wgruppe, '??' ) AS gefszen 6058 , prj.zeige__pp_psgefszenario.notizen 6059 -- 2 6060 , COALESCE( reprgefszen.wgruppe, '??' ) AS reprgefszen 6061 , prj.zeige__pp_psgefszenario.spr_uebvar_id_ursp 6062 -- 4 6063 , prj.zeige__pp_psgefszenario.spr_uebvar_id 6064 , prj.zeige__pp_psgefszenario.spr_uebvar_id_reprgefszen 6065 -- 6 6066 , prj.zeige__pp_psgefszenario.id 6067 FROM 6068 prj.zeige__pp_psgefszenario 6069 LEFT OUTER JOIN spr.zeige__wgruppe AS gefszen ON ( 6070 prj.zeige__pp_psgefszenario.spr_uebvar_id = gefszen.spr_uebvar_id 6071 AND 6072 -- 6073 -- Sprache Auswählen 6074 -- 6075 gefszen.spr_sprachen_id = """ + str( sprSprachenId ) + """ ) 6076 6077 LEFT OUTER JOIN spr.zeige__wgruppe AS reprgefszen ON ( 6078 prj.zeige__pp_psgefszenario.spr_uebvar_id_reprgefszen 6079 = reprgefszen.spr_uebvar_id 6080 AND 6081 -- 6082 -- Sprache Auswählen 6083 -- 6084 reprgefszen.spr_sprachen_id = """ + str( sprSprachenId ) + """ ) 6085 6086 LEFT OUTER JOIN spr.zeige__wgruppe AS ursp ON ( 6087 prj.zeige__pp_psgefszenario.spr_uebvar_id_ursp 6088 = ursp.spr_uebvar_id 6089 AND 6090 -- 6091 -- Sprache Auswählen 6092 -- 6093 ursp.spr_sprachen_id = """ + str( sprSprachenId ) + """ ) 6094 WHERE 6095 -- 6096 -- Projekt auswählen 6097 -- 6098 prj.zeige__pp_psgefszenario.prj_projekte_id = """ + str( prjProjekteId ) + """ 6099 AND 6100 -- 6101 -- Gefahrenszenario auswählen 6102 -- 6103 prj.zeige__pp_psgefszenario.ps_gefszenario_id = """ 6104 + str( psGefszenarioId ) + """ 6105 ;""" ) 6106 6107 6108 # 6109 # -- 1.) Gefahrenszenario / Notizen (im GUI angezeigt) ------------------ 6110 # 6111 ListBoxGefSzen.loescheAlles() 6112 ListBoxGefSzen.nimmWert( wert = self.__gibWert__( 0, 0 ) + '\t|\t' + self.__gibWert__( 0, 1 ) 6113 , clientData = [ self.__gibWert__( 0, 4 ) 6114 # -- notizen --------------------------- 6115 , self.__gibWert__( 0, 1 ) 6116 # -- prj.pp_psgefszenario.id ----------- 6117 , self.__gibWert__( 0, 6 ) 6118 # -- spr_uebvar_id_ursp ---------------- 6119 , self.__gibWert__( 0, 3 ) ] ) 6120 ListBoxGefSzen.SetSelection( 0 ) 6121 6122 6123 6124 # 6125 # -- 2.) repräsentatives Gefahrenszenario (im GUI angezeigt) ---------- 6126 # 6127 ListBoxReprGefSzen.loescheAlles() 6128 ListBoxReprGefSzen.nimmWert( 6129 wert = self.__gibWert__( 0, 2 ) 6130 , clientData = [ self.__gibWert__( 0, 5 ) ] ) 6131 ListBoxReprGefSzen.SetSelection( 0 )

6132 6133 6134 6135 6136 # 6137 # ------------------------------------------------------------------------------------ 6138 # -- Sicherheitsanforderungen selektieren -------------------------- 6139 # -- Sicht >prj.zeige__prtprotokoll< selektieren -------------------------- 6140 # ------------------------------------------------------------------------------------ 6141 #

6142 - def selektiere__psPrtProtokoll( self, TreeCtrlErg, prjProjekteId, sprSprachenId, psGefszenarioId, prtTypId ):

6143 """ 6144 Methode zur Darstellung der Sicherheitsanforderungen. 6145 6146 @note: Das übergebene Baumstrukturobjekt (C{TreeCtrlErg}) wird verändert ! 6147 6148 @param TreeCtrlErg: Es ist das Baumstrukturobjekt zu übergeben, welches die Sicherheitsanforderungen aufnimmt. 6149 @type TreeCtrlErg: TreeCtrlErg 6150 6151 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 6152 @type prjProjekteId: Ganzzahl 6153 6154 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 6155 @type sprSprachenId: Ganzzahl 6156 6157 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 6158 @type psGefszenarioId: Ganzzahl 6159 6160 @param prtTypId: Es ist die Datenbankidentifikationsnummer (C{prt.typ.id}) des Typs der Sicherheitsanforderung zu übergeben, die dargestellt werden soll. 6161 @type prtTypId: Ganzzahl 6162 """ 6163 6164 # 6165 # -- SQL-Abfrageergebnis einschränken ---------------------------------- 6166 # 6167 prtTyp = "" 6168 6169 vorgSEL = "" 6170 vorgLEFTJOIN = "" 6171 vorgORDERBY = "" 6172 6173 gefszenario = "" 6174 gefszenarioProjekt = "" 6175 6176 6177 # 6178 # -- Typ der SiAnf einschränken ------------------------------------------ 6179 # 6180 if( prtTypId is not None ) : 6181 6182 prtTyp = """ 6183 AND 6184 -- 6185 -- Typ der Sicherheitsanforderung einschränken 6186 -- 6187 prj.zeige__prtprotokoll.prt__typ__id = """ + str( prtTypId ) + """ 6188 """ 6189 6190 # 6191 # -- Vorgänger berücksichtigen ------------------------------------------ 6192 # 6193 else : 6194 6195 vorgSEL = """ 6196 -- (5) 6197 , COALESCE( prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prt_protokoll_id_vorg, 0 ) AS prt_prot_id_vorg""" 6198 6199 vorgLEFTJOIN = """ 6200 6201 -- 6202 -- Vorgänger zum Protokolleintrag anzeigen 6203 -- 6204 LEFT OUTER JOIN prj.zeige__prtprotokolltabellen 6205 ON ( 6206 prj.zeige__prtprotokolltabellen.prt__protokoll__id = 6207 prj.zeige__prtprotokoll.prt__protokoll__id 6208 AND 6209 prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prj_projekte_id = 6210 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id 6211 )""" 6212 6213 vorgORDERBY = """ 6214 prt_prot_id_vorg 6215 ,""" 6216 6217 6218 6219 # 6220 # -- Projekt einschränken -------------------------------------------------- 6221 # 6222 if( psGefszenarioId is None ) : 6223 6224 gefszenarioProjekt = """ 6225 AND 6226 -- 6227 -- Projekt einschränken 6228 -- 6229 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id = """ + str( prjProjekteId ) 6230 6231 6232 # 6233 # -- Gefahrenszenario einschränken ------------------------------------------ 6234 # 6235 else : 6236 6237 gefszenario = """ 6238 -- 6239 -- Gefahrenszenrio einschränken 6240 -- 6241 , prj.zeige__pl_prtpsgefszenario 6242 , prj.zeige__pl_prtpsgefszenario_le""" 6243 6244 gefszenarioProjekt = """ 6245 AND 6246 -- 6247 -- Gefahrenszenario einschränken 6248 -- 6249 prj.zeige__prtprotokoll.prt__protokoll__id = prj.zeige__pl_prtpsgefszenario.prt_protokoll_id 6250 AND 6251 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id = 6252 prj.zeige__pl_prtpsgefszenario.prj_projekte_id 6253 AND 6254 prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id = 6255 prj.zeige__pl_prtpsgefszenario.id 6256 AND 6257 prj.zeige__pl_prtpsgefszenario.logentfernt = false 6258 AND 6259 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id = """ + str( psGefszenarioId ) 6260 6261 6262 # 6263 # -- Gefahrenszenario und Projekt einschränken -------------------------- 6264 # 6265 if( prjProjekteId is not None ) : 6266 6267 gefszenarioProjekt = gefszenarioProjekt + """ 6268 AND 6269 -- 6270 -- Projekt einschränken 6271 -- 6272 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id = """ + str( prjProjekteId ) 6273 6274 # 6275 # -- SQL-Abfrage zusammenstellen ------------------------------------------ 6276 # 6277 sql = ( """ 6278 -- 6279 -- Wenn die Protokolleinträge projektübergreifend angezeigt werden, treten Protokolleinträge auf, die gleichzeitig 6280 -- einen Vorgänger UND keinen Vorgänger besitzen (da in den Projekten entsprechend definiert) 6281 -- Die Bereinigung erfolgt nach dem Auslesen mittels Python-Routine 6282 -- 6283 SELECT DISTINCT 6284 -- 0 6285 prj.zeige__prtprotokoll.prt__protokoll__id 6286 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS psanf 6287 -- 2 6288 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen 6289 , prj.zeige__prtprotokoll.prt__typ__id 6290 -- 4 6291 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id""" 6292 + vorgSEL + """ 6293 FROM 6294 prj.zeige__prtprotokoll 6295 -- 6296 -- Sicherheitsanforderung 6297 -- 6298 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 6299 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id = 6300 spr.zeige__wgruppe.spr_uebvar_id 6301 AND 6302 -- 6303 -- Sprache Auswählen 6304 -- 6305 spr.zeige__wgruppe.spr_sprachen_id = """ 6306 + str( sprSprachenId ) + """ 6307 )""" 6308 + vorgLEFTJOIN 6309 + gefszenario + """ 6310 WHERE 6311 -- 6312 -- Aspekt der Protokolleinträge auf 'Sicherheitsanforderung' einschränken 6313 -- 6314 prj.zeige__prtprotokoll.prt__typ__aspekt = 'SF'""" 6315 + prtTyp 6316 + gefszenarioProjekt 6317 + """ 6318 ORDER BY""" 6319 + vorgORDERBY + """ 6320 prj.zeige__prtprotokoll.prt__protokoll__id 6321 ;""" ) 6322 6323 6324 # 6325 # -- SQL-Abfrage ausführen -------------------------------------------------- 6326 # 6327 self.__dbAbfrage__( sql ) 6328 6329 6330 # 6331 # -- Alle Einträge löschen -------------------------------------------------- 6332 # 6333 TreeCtrlErg.loescheBaum() 6334 6335 6336 # 6337 # -- es sind keine SiAnf darzustellen ---------------------------------- 6338 # 6339 if( self.__gibAnzZeilen__() == 0 ) : return 6340 6341 6342 # 6343 # -- SiAnf aussortieren, die gleichzeitig einen Vorgänger ------------------ 6344 # -- UND keinen Vorgänger besitzen, wenn KEIN Typ der ------------------ 6345 # -- SiAnf ausgewählt wurde ------------------ 6346 # 6347 6348 # 6349 # -- 0.) prt.protokoll.id 6350 # 6351 posInWerte = [] 6352 6353 # -- 0.) lfd. Nr. des Vorgängers im TreeCtrl 6354 # -- 1.) prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id 6355 # -- 2.) prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen 6356 # 6357 werte = [] 6358 6359 for i in range( self.__gibAnzZeilen__() ): 6360 6361 # 6362 # -- Technische oder Organisatorische Maßnahme ------------------ 6363 # -- 6364 # 20 | 01: Technische Maßnahme (Konstruktion) -- 6365 # 21 | 01: Technische Maßnahme (Sicherheitsfunktion) -- 6366 # -- 6367 # 22 | 01: Dokumentationsanforderung an den Fahrzeughersteller -- 6368 # 23 | 01: Vom Fahrzeughersteller durchzuführende Prüfung -- 6369 # 24 | 02: Während des Betriebseinsatzes durchzuführende Maßnahme -- 6370 # 25 | 02: In die Bedienungsanleitung aufzunehmende Anforderung -- 6371 # 26 | 03: Instandhaltungsmaßnahme -- 6372 # 27 | 03: In die Instandhaltungsdokumentation aufzunehmende Anforderung -- 6373 # -- 6374 # 6375 istTechnSiAnf = ( self.__gibWert__( i, 3 ) in [20, 21] ) 6376 6377 # 6378 # -- kein Vorgänger vorhanden bzw. Typ der SiAnf ausgewählt ---------- 6379 # 6380 if( ( prtTypId is None and self.__gibWert__( i, 5 ) == 0 ) 6381 or prtTypId is not None ) : 6382 6383 posInWerte.append( self.__gibWert__( i, 0 ) ) 6384 6385 werte.append([ None 6386 , self.__gibWert__( i, 1 ) 6387 , self.__gibWert__( i, 2 ) 6388 , istTechnSiAnf 6389 , self.__gibWert__( i, 4 ) 6390 , self.__gibWert__( i, 3 ) ]) 6391 6392 endeKeinVorg = i 6393 6394 6395 # 6396 # -- Vorgänger ist vorhanden ------------------------------------------ 6397 # 6398 else : 6399 6400 # 6401 # -- lfd. Nr. des Vorgängers im TreeCtrl ermitteln ------------------ 6402 # 6403 tmpLfdNrVorgaenger = posInWerte.index( self.__gibWert__( i, 5 ) ) 6404 6405 # 6406 # -- SiAnf ist bereits ohne Vorgänger vorhanden ------------------ 6407 # 6408 if( self.__gibWert__( i, 0 ) in posInWerte 6409 and posInWerte.index( self.__gibWert__( i, 0 ) ) <= endeKeinVorg ) : 6410 6411 tmpPosInWerte = posInWerte.index( self.__gibWert__( i, 0 ) ) 6412 6413 werte[tmpPosInWerte] = [ tmpLfdNrVorgaenger 6414 , self.__gibWert__( i, 1 ) 6415 , self.__gibWert__( i, 2 ) 6416 , istTechnSiAnf 6417 , self.__gibWert__( i, 4 ) 6418 , self.__gibWert__( i, 3 ) ] 6419 6420 else : 6421 6422 posInWerte.append( self.__gibWert__( i, 0 ) ) 6423 6424 werte.append([ tmpLfdNrVorgaenger 6425 , self.__gibWert__( i, 1 ) 6426 , self.__gibWert__( i, 2 ) 6427 , istTechnSiAnf 6428 , self.__gibWert__( i, 4 ) 6429 , self.__gibWert__( i, 3 ) ]) 6430 6431 6432 6433 # 6434 # -- SiAnf übernehmen -------------------------------------------------- 6435 # 6436 for i in range( len( posInWerte ) ): 6437 6438 # 6439 # -- SiAnf hinzufügen ------------------------------------------ 6440 # 6441 wertIdVorg = None 6442 if( werte[i][0] is not None ) : 6443 wertIdVorg = werte[i][0] + 1 6444 6445 # 6446 # -- Techn./Org. Maßnahme als Klartext -------------------------- 6447 # 6448 if( werte[i][3] ) : txtTechnSiAnf = " [T]" 6449 else : txtTechnSiAnf = " [O]" 6450 6451 # 6452 # -- SiAnf übernehmen ------------------------------------------ 6453 # 6454 TreeCtrlErg.nimmWert( wert = zk.gibIdWertNotizen( id = posInWerte[i] 6455 , zusInfo = txtTechnSiAnf 6456 , wert = werte[i][1] 6457 , notizen = werte[i][2] ) 6458 , wertId = ( i + 1 ) 6459 , dbId = posInWerte[i] 6460 , wertIdVorgaenger = wertIdVorg 6461 , clientData = [ werte[i][3] 6462 , werte[i][4] 6463 , werte[i][2] 6464 , werte[i][5] ] 6465 ) 6466 6467 6468 6469 # 6470 # -- Baum anzeigen ---------------------------------------------------------- 6471 # 6472 TreeCtrlErg.erzeugeBaum() 6473 TreeCtrlErg.markiereWert()

6474 6475 6476 6477 6478 # 6479 # ------------------------------------------------------------------------------------ 6480 # -- die zugeordneten Strukturpunkte in >wxListBox<, -------------------------- 6481 # -- Tabelle >prj.personen< selektieren -------------------------- 6482 # ------------------------------------------------------------------------------------ 6483 #

6484 - def selektiere__prjPersonen( self, wxListBox, prjProjekteId, strStrktId_li ):

6485 """ 6486 Methode zur Selektion der Person(en) in der Auswahlliste (C{wxListBox}), welche im aktuell übergebenen Projekt für den aktuell übergebenen Strukturpunkt (links) verantwortlich ist. 6487 6488 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 6489 6490 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Personen enthält. 6491 @type wxListBox: wxPython - ListBox 6492 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 6493 @type prjProjekteId: Ganzzahl 6494 @param strStrktId_li: Es ist die Datenbankidentifikationsnummer (C{str.strkt.id}) des Strukturpunktes (links) zu übergeben, dessen zugeordnete verantwortliche Person(en) selektiert werden soll(en). 6495 @type strStrktId_li: Ganzzahl 6496 """ 6497 6498 # 6499 # wenn kein Projekt ausgewählt ist (prjProjekteId = 0), wird die Methode verlassen 6500 # 6501 if prjProjekteId == 0: 6502 return 6503 6504 # 6505 # SQL-Abfrage ausführen, 6506 # die gelesenen Werte der ListBox zuordnen 6507 # 6508 self.__dbAbfrage__( """ 6509 SELECT DISTINCT 6510 prj__pp_strstrkt__prj_personen_id 6511 FROM 6512 prj.zeige__strstrkt 6513 WHERE 6514 -- 6515 -- Strukturpunkt (links) auswählen 6516 -- 6517 str__strkt__id = """ + str( strStrktId_li ) + """ 6518 AND 6519 -- 6520 -- Projekt auswählen (bezogen auf den Strukturpunkt) 6521 -- 6522 prj_projekte_id = """ + str( prjProjekteId ) + """ 6523 ;""" ) 6524 6525 prjPersonenId = [] 6526 6527 for i in range( self.__gibAnzZeilen__() ) : 6528 prjPersonenId.append( self.__gibWert__( i, 0 ) ) 6529 6530 self.WxListBoxSelektieren( wxListBox, prjPersonenId )

6531 6532 6533 6534 6535 # 6536 # ------------------------------------------------------------------------------------ 6537 # -- Alle Eingabefelder des Gefahrenprotokolls in Abhängigkeit ---------- 6538 # -- von der gewählten Protokoll.-Id setzen ---------- 6539 # ------------------------------------------------------------------------------------ 6540 #

6541 - def selektiere__prtProtokoll( self, wxCheckBoxIntern, wxCheckBoxErledigt, wxComboBoxTypPE, wxmskCtrlDatumPE, LBSpWTALBetPers, wxmskCtrlAntwDatum, wxmskCtrlTermin, LBSpWTALAntwPers, prjProjekteId, sprSprachenId, prtProtokollId ):

6542 """ 6543 Methode zur Initialisierung aller Eingabefelder des Gefahrenprotokolls. 6544 6545 @note: Die übergebenen Eingabefelder werden verändert ! 6546 6547 @param wxCheckBoxIntern: CheckBox zur Markierung 'Intern' 6548 @type wxCheckBoxIntern: wxPython - CheckBox 6549 6550 @param wxCheckBoxErledigt: CheckBox zur Markierung 'Erledigt' 6551 @type wxCheckBoxErledigt: wxPython - CheckBox 6552 6553 @param wxComboBoxTypPE: ComboBox aus der der Typ des Protokolleintrages entnehmbar ist 6554 @type wxComboBoxTypPE: wxPython - ComboBox 6555 6556 @param wxmskCtrlDatumPE: Datum-Eingabefeld, zur Spezifikation des Datums des Protokolleintrages 6557 @type wxmskCtrlDatumPE: wxPython - wxmskCtrl 6558 6559 @param LBSpWTALBetPers: Auswahlliste, die die beteiligten Personen aufnimmt 6560 @type LBSpWTALBetPers: ListBoxSpWTitelAL 6561 6562 @param wxmskCtrlAntwDatum: Datum-Eingabefeld, zur Spezifikation des Datums der Antwort 6563 @type wxmskCtrlAntwDatum: wxPython - wxmskCtrl 6564 6565 @param wxmskCtrlTermin: Datum-Eingabefeld, zur Spezifikation des Termins 6566 @type wxmskCtrlTermin: wxPython - wxmskCtrl 6567 6568 @param LBSpWTALAntwPers: Auswahlliste, die die angesprochenen Personen aufnimmt 6569 @type LBSpWTALAntwPers: ListBoxSpWTitelAL 6570 6571 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 6572 @type prjProjekteId: Ganzzahl 6573 6574 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 6575 @type sprSprachenId: Ganzzahl 6576 6577 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Protokolleintrages zu übergeben. 6578 @type prtProtokollId: Ganzzahl 6579 """ 6580 6581 # 6582 # -- 6583 # -- SQL-Abfrage ausführen, ---------- 6584 # -- die gelesenen Werte der ListBox zuordnen ---------- 6585 # -- ---------- 6586 # -- ---------- 6587 # -- Es werden drei Fälle abgedeckt: ---------- 6588 # -- ............................... ---------- 6589 # -- ---------- 6590 # -- 1. projektspezifischer Protokolleintrag ---------- 6591 # -- id > 0 AND prj_personen_id = 0 AND ---------- 6592 # -- prj_projekte_id > 0 AND prt_protokoll_id > 0 ---------- 6593 # -- ---------- 6594 # -- 2. beteiligte Personen zuordnen ---------- 6595 # -- id > 0 AND prj_personen_id > 0 AND prj_projekte_id > 0 ---------- 6596 # -- AND prt_protokoll_id > 0 AND spr_uebvar_id = 0 ---------- 6597 # -- AND teilnehmer = true ---------- 6598 # -- ---------- 6599 # -- 3. der Protokolleintrag ist eine Frage / Aufgabe ---------- 6600 # -- id > 0 AND prj_personen_id > 0 AND prj_projekte_id > 0 ---------- 6601 # -- AND prt_protokoll_id > 0 AND spr_uebvar_id = 0 ---------- 6602 # -- AND teilnehmer = false AND termin IS NOT NULL ---------- 6603 # -- ---------- 6604 # -- ---------- 6605 # -- -------------------------------------------------------------------------- 6606 # 6607 self.__dbAbfrage__( """ 6608 -- 6609 -- Details zu den Protokolleinträgen 6610 -- 6611 SELECT DISTINCT 6612 -- 0 6613 prj.zeige__prtprotokoll.prt__typ__id 6614 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen 6615 -- 2 6616 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS proteintrag 6617 , to_char( prj.zeige__prtprotokoll.prj__pp_prtprotokoll__datuhrz, 'DD.MM.YYYY' ) 6618 -- 4 6619 , to_char( prj.zeige__prtprotokoll.prj__pp_prtprotokoll__duanfrage, 'DD.MM.YYYY' ) 6620 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__erledigt 6621 -- 6 6622 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__intern 6623 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_personen_id 6624 -- 8 6625 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__teilnehmer 6626 , to_char( prj.zeige__prtprotokoll.prj__pp_prtprotokoll__termin, 'DD.MM.YYYY' ) 6627 -- 10 6628 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__id 6629 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id 6630 FROM 6631 prj.zeige__prtprotokoll 6632 -- 6633 -- Text der Protokolleinträge darstellen 6634 -- 6635 LEFT OUTER JOIN spr.zeige__wgruppe 6636 ON ( 6637 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id = 6638 spr.zeige__wgruppe.spr_uebvar_id 6639 AND 6640 -- 6641 -- Sprache Auswählen 6642 -- 6643 spr.zeige__wgruppe.spr_sprachen_id = """ 6644 + str( sprSprachenId ) + """ 6645 ) 6646 WHERE 6647 -- 6648 -- Projekt auswählen 6649 -- 6650 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id = """ 6651 + str( prjProjekteId ) + """ 6652 AND 6653 -- 6654 -- Protokolleintrag auswählen 6655 -- 6656 prj.zeige__prtprotokoll.prt__protokoll__id = """ + str( prtProtokollId ) + """ 6657 ;""" ) 6658 6659 6660 # 6661 # -- alte Einträge löschen / auf Standardwert setzen -------------------------- 6662 # 6663 wxCheckBoxIntern.loescheAlles() 6664 wxCheckBoxErledigt.loescheAlles() 6665 6666 wxComboBoxTypPE.SetSelection( 0 ) 6667 6668 wxmskCtrlDatumPE.loescheAlles() 6669 6670 LBSpWTALBetPers.schiebeAlleRechts() 6671 del LBSpWTALBetPers.ListBox__li.clientData[:] 6672 6673 wxmskCtrlAntwDatum.loescheAlles() 6674 wxmskCtrlTermin.loescheAlles() 6675 6676 LBSpWTALAntwPers.schiebeAlleRechts() 6677 del LBSpWTALAntwPers.ListBox__li.clientData[:] 6678 6679 6680 # 6681 # -- Selektionen setzen -------------------------------------------------- 6682 # 6683 for i in range( self.__gibAnzZeilen__() ): 6684 prj_personen_id = self.__gibWert__( i, 7 ) 6685 6686 # 6687 # -- Es ist der projektspezifische Protokolleintrag zu setzen -- 6688 # 6689 if prj_personen_id == 0 : 6690 6691 # 6692 # -- Intern ---------------------------------------------------------- 6693 # 6694 wxCheckBoxIntern.nimmWert( wert = ( str( self.__gibWert__( i, 6 ) ) == 't' ) ) 6695 6696 # 6697 # -- Erledigt -------------------------------------------------- 6698 # 6699 wxCheckBoxErledigt.nimmWert( wert = ( str( self.__gibWert__( i, 5 ) ) == 't' ) ) 6700 6701 # 6702 # -- Typ des Protokolleintrages ---------------------------------- 6703 # 6704 for k in range( wxComboBoxTypPE.GetCount() ) : 6705 if wxComboBoxTypPE.gibClientData( selection = k, lfdNr = 0 ) == self.__gibWert__( i, 0 ): 6706 break 6707 wxComboBoxTypPE.SetSelection( k ) 6708 6709 # 6710 # -- Datum des Protokolleintrages ---------------------------------- 6711 # 6712 wxmskCtrlDatumPE.nimmWert( wert = self.__gibWert__( i, 3 ) ) 6713 6714 # 6715 # -- Es werden die beteiligten Personen bzw. die Daten ---------- 6716 # -- bei Fragen / Aufgaben gesetzt ---------- 6717 # 6718 else : 6719 # 6720 # -- Beteiligte Personen ------------------------------------------ 6721 # 6722 if str( self.__gibWert__( i, 8 ) ) == 't' : 6723 LBSpWTALBetPers.schiebeLinks( self.__gibWert__( i, 7 ) ) 6724 LBSpWTALBetPers.ListBox__li.clientData.append( self.__gibWert__( i, 10 ) ) 6725 6726 # 6727 # -- Bitte um Antwort versendet am ... -------------------------- 6728 # -- Termin -------------------------- 6729 # -- Bitte um Antwort an ... -------------------------- 6730 # 6731 else : 6732 wxmskCtrlAntwDatum.nimmWert( wert = self.__gibWert__( i, 4 ) ) 6733 6734 wxmskCtrlTermin.nimmWert( wert = self.__gibWert__( i, 9 ) ) 6735 6736 LBSpWTALAntwPers.schiebeLinks( self.__gibWert__( i, 7 ) ) 6737 LBSpWTALAntwPers.ListBox__li.clientData.append( self.__gibWert__( i, 10 ) )

6738 6739 6740 6741 # 6742 # ------------------------------------------------------------------------------------ 6743 # -- Strukturpunkte selektieren ---------------------------------- 6744 # -- Sicht >prj.zeige__strstrkt< selektieren ---------------------------------- 6745 # ------------------------------------------------------------------------------------ 6746 #

6747 - def selektiere__psPrtStrkt( self, SiAnfStrktDok, prjProjekteId, sprSprachenId, prtProtokollId, psGefszenarioId, strNameId ):

6748 """ 6749 Methode zur Darstellung der Strukturpunkte, die einem Protokolleintrag, einer Sicherheitsanforderung, Terminplaneintrag oder Gefarenszenario zugeordnet sind. 6750 6751 @note: Die übergebene Auswahlliste (C{SiAnfStrktDok}) wird verändert ! 6752 6753 @param SiAnfStrktDok: Es ist das Listenobjekt zu übergeben, welches die Strukturpunkte aufnimmt. 6754 @type SiAnfStrktDok: wxPython - SiAnfStrktDok 6755 6756 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 6757 @type prjProjekteId: Ganzzahl 6758 6759 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 6760 @type sprSprachenId: Ganzzahl 6761 6762 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 6763 @type prtProtokollId: Ganzzahl 6764 6765 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 6766 @type psGefszenarioId: Ganzzahl 6767 6768 @param strNameId: Es ist die Datenbankidentifikationsnummer (C{str.name.id}) der Strukturbezeichnung zu übergeben, die dargestellt werden soll. 6769 @type strNameId: Ganzzahl 6770 """ 6771 6772 # 6773 # -- SQL-Abfrage ausführen -------------------------------------------------- 6774 # 6775 self.__dbAbfrage__( self.gibSQL_psPrtStrkt( prjProjekteId = prjProjekteId 6776 , sprSprachenId = sprSprachenId 6777 , prtProtokollId = prtProtokollId 6778 , psGefszenarioId = psGefszenarioId 6779 , strNameId = strNameId ) ) 6780 6781 6782 # 6783 # -- Alle Einträge löschen -------------------------------------------------- 6784 # 6785 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.loescheBaum() 6786 6787 6788 # 6789 # -- es sind keine Strukturpunkte darszustellen -------------------------- 6790 # 6791 if( self.__gibAnzZeilen__() == 0 ) : return 6792 6793 6794 # 6795 # -- Strukturnamen übernehmen ------------------------------------------ 6796 # 6797 strNameId = SiAnfStrktDok.gibId( wertId = self.__gibWert__( 0, 3 ) 6798 , istStrName = True ) 6799 6800 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.nimmWert( wert = self.__gibWert__( 0, 4 ) 6801 , dbId = self.__gibWert__( 0, 4 ) 6802 , wertId = strNameId ) 6803 6804 6805 # 6806 # -- Strukturpunkte übernehmen ------------------------------------------ 6807 # 6808 for i in range( self.__gibAnzZeilen__() ): 6809 6810 # 6811 # -- Strukturnamen hinzufügen ---------------------------------- 6812 # 6813 if( strNameId != SiAnfStrktDok.gibId( wertId = self.__gibWert__( i, 3 ) 6814 , istStrName = True ) ) : 6815 6816 strNameId = SiAnfStrktDok.gibId( wertId = self.__gibWert__( i, 3 ) 6817 , istStrName = True ) 6818 6819 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.nimmWert( wert = self.__gibWert__( i, 4 ) 6820 , dbId = self.__gibWert__( 0, 4 ) 6821 , wertId = strNameId ) 6822 6823 6824 # 6825 # -- Strukturpunkte hinzufügen ---------------------------------- 6826 # 6827 wertIdVorg = strNameId 6828 if( ( len( str( self.__gibWert__( i, 2 ) ) ) != 0 ) 6829 and ( prtProtokollId is None ) 6830 and ( psGefszenarioId is None ) ) : 6831 6832 wertIdVorg = SiAnfStrktDok.gibId( wertId = self.__gibWert__( i, 2 ) ) 6833 6834 # 6835 # -- prj.p_prtstrstrkt.str_strkt_id 6836 # -- prj.p_prtstrstrkt.id 6837 # -- prj.p_prtstrstrkt.notizen 6838 # 6839 clientData = [ self.__gibWert__( i, 0 ) ] 6840 if( prtProtokollId is not None ) : 6841 clientData.append( self.__gibWert__( i, 5 ) ) 6842 else : 6843 clientData.append( None ) 6844 6845 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.nimmWert( wert = self.__gibWert__( i, 1 ) 6846 , wertId = SiAnfStrktDok.gibId( wertId = self.__gibWert__( i, 0 ) ) 6847 , dbId = SiAnfStrktDok.gibId( wertId = self.__gibWert__( i, 0 ) ) 6848 , wertIdVorgaenger = wertIdVorg 6849 , clientData = clientData ) 6850 6851 6852 # 6853 # -- Baum anzeigen ---------------------------------------------------------- 6854 # 6855 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.erzeugeBaum() 6856 SiAnfStrktDok.TreeCtrlErg__Id.wxObjekt.markiereWert()

6857 6858 6859 6860 6861 6862 # 6863 # ------------------------------------------------------------------------------------ 6864 # -- Risikomatrix auslesen -------------------------------------------------- 6865 # ------------------------------------------------------------------------------------ 6866 #

6867 - def selektiere__psRisikomatrix( self, CBHaeufig, LBHaeufigBegr, CBGefStufe, LBGefStufeBegr, TCASRisikostufe, LBRisikoStufeBegr, psGefszenarioId, prjProjekteId, sprSprachenId, istCBHaeufigAenderung ):

6868 """ 6869 Methode zum Setzen der (C{wx Objekte}), welche die Häufigkeit, die Auswirkung und das Risiko repräsentieren. 6870 6871 @note: Die übergebenen (C{wx Objekte}) werden verändert ! 6872 6873 @param CBHaeufig: Es ist die Auswahlliste der Häufigkeiten des Gefahrenszenarios anzugeben 6874 @type CBHaeufig: ComboBoxErg 6875 @param LBHaeufigBegr: Es ist das Texteingabefeld zu übergeben, welches die Begründung der Häufigkeit und die internen Notizen aufnimmt. 6876 @type LBHaeufigBegr: TextCtrlErg 6877 6878 @param CBGefStufe: Es ist die Auswahlliste der Gefahrenstufen des Gefahrenszenarios anzugeben 6879 @type CBGefStufe: ComboBoxErg 6880 @param LBGefStufeBegr: Es ist das Texteingabefeld zu übergeben, welches die Begründung der Gefahrenstufen und die internen Notizen aufnimmt. 6881 @type LBGefStufeBegr: TextCtrlErg 6882 6883 @param TCASRisikostufe: Es ist das statische Textfeld mit Auswahlliste der Risikostufen anzugeben 6884 @type TCASRisikostufe: TextCtrlAuswStatisch 6885 @param LBRisikoStufeBegr: Es ist das Texteingabefeld zu übergeben, welches die Erläuterung der Risikostufe und die internen Notizen aufnimmt. 6886 @type LBRisikoStufeBegr: TextCtrlErg 6887 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 6888 @type psGefszenarioId: Ganzzahl 6889 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 6890 @type prjProjekteId: Ganzzahl 6891 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 6892 @type sprSprachenId: Ganzzahl 6893 6894 @param istCBHaeufigAenderung: C{True} - Die Häufigkeit wurde geändert 6895 @type istCBHaeufigAenderung: Boolean 6896 """ 6897 6898 # 6899 # -- Werte ------------------------------------------------------------------ 6900 # -- ---------- 6901 # -- werte[0] ... Häufigkeit oder Gefahrenstufe ---------- 6902 # -- werte[1] ... Risikostufe ---------- 6903 # -- ---------- 6904 # -- werte[ 0 , 1 , 2 , 3 , 4 ] ---------- 6905 # -- werte[abk_id, istGefSzen, notizen, spr_uebvar_id_zus, begr] ---------- 6906 # 6907 werte = [[ 0, None, zk.gibZk( "" ), 0, zk.gibZk( "" ), zk.gibZk( "" ), 0 ] 6908 , [ 0, None, zk.gibZk( "" ), 0, zk.gibZk( "" ), zk.gibZk( "" ), 0 ]] 6909 6910 if( istCBHaeufigAenderung ) : werte[0][0] = CBHaeufig.gibClientData() 6911 else : werte[0][0] = CBGefStufe.gibClientData() 6912 6913 abkId = str( werte[0][0] ) 6914 6915 6916 # 6917 # -- SQL-Abfragen ausführen, wenn Häufigkeit und Gefahrenstufe gegeben sind -- 6918 # 6919 if( CBHaeufig.gibClientData() != 0 and CBGefStufe.gibClientData() != 0 ) : 6920 6921 # 6922 # -- Risikostufe ermitteln ------------------------------------------ 6923 # 6924 self.__dbAbfrage__( """ 6925 -- 6926 -- Risikobewertung durchführen 6927 -- 6928 SELECT DISTINCT 6929 ps__abk__id_rstufe 6930 FROM 6931 ps.zeige__risikomatrix_en50126 6932 WHERE 6933 -- 6934 -- Häufigkeit und Gefahrenstufe einschränken 6935 -- 6936 ps__abk__id_hfg = """ + str( CBHaeufig.gibClientData() ) + """ 6937 AND 6938 ps__abk__id_gstufe = """ + str( CBGefStufe.gibClientData() ) + """ 6939 ;""" ) 6940 6941 if( self.__hatWerte__() ) : 6942 werte[1][0] = self.__gibWert__( 0, 0 ) 6943 abkId = abkId + ", " + str( werte[1][0] ) 6944 6945 6946 # 6947 # -- SQL-Abfrage ausführen (Werte ermitteln) -------------------------- 6948 # 6949 self.__dbAbfrage__( """ 6950 -- 6951 -- Begründung / Notizen auslesen 6952 -- 6953 SELECT 6954 -- 0 6955 ps_abk_id 6956 , true AS istgefszen 6957 -- 2 6958 , notizen 6959 , spr_uebvar_id_zus 6960 -- 4 6961 , COALESCE( begr.wgruppe, '??' ) AS begr 6962 FROM 6963 prj.zeige__pl_psgefabk 6964 LEFT OUTER JOIN spr.zeige__wgruppe AS begr ON ( 6965 spr_uebvar_id_zus = begr.spr_uebvar_id 6966 AND 6967 -- 6968 -- Sprache Auswählen 6969 -- 6970 begr.spr_sprachen_id = """ + str( sprSprachenId ) + """ 6971 ) 6972 WHERE 6973 -- 6974 -- Projekt einschränken 6975 -- 6976 prj_projekte_id = """ + str( prjProjekteId ) + """ 6977 AND 6978 -- 6979 -- Gefahrenszenario einschränken 6980 -- 6981 ps_gefszenario_id = """ + str( psGefszenarioId ) + """ 6982 AND 6983 -- 6984 -- Abkürzung 6985 -- 6986 ps_abk_id IN( """ + abkId + """ ) 6987 ;""" ) 6988 6989 6990 # 6991 # -- Werte übernehmen ------------------------------------------ 6992 # -- werte[0] ... Häufigkeit oder Gefahrenstufe ------------------ 6993 # -- werte[1] ... Risikostufe ------------------ 6994 # 6995 for i in range( self.__gibAnzZeilen__() ) : 6996 if( self.__gibWert__( i, 0 ) == werte[0][0] ) : akt = 0 6997 else : akt = 1 6998 6999 if( werte[akt][1] == None or self.__gibWert__( i, 1 ) == True ) : 7000 werte[akt][1] = self.__gibWert__( i, 1 ) 7001 werte[akt][2] = zk.gibZk( self.__gibWert__( i, 2 ) ) 7002 werte[akt][3] = self.__gibWert__( i, 3 ) 7003 werte[akt][4] = zk.gibZk( self.__gibWert__( i, 4 ) ) 7004 7005 7006 # 7007 # -- 1.) Häufigkeit (im GUI angezeigt) ---------------------------------- 7008 # 7009 if( istCBHaeufigAenderung ) : 7010 7011 LBHaeufigBegr.loescheAlles() 7012 LBHaeufigBegr.nimmWert( wert = werte[0][4] + '\t|\t' + werte[0][2] 7013 , clientData = [ werte[0][3] 7014 # -- >notizen< ------------------------- 7015 , werte[0][2] ] ) 7016 7017 # -- >prj.pp_psgefszenario.id< --------- 7018 #, self.__gibWert__( 0, 7 ) ] ) 7019 LBHaeufigBegr.SetSelection( 0 ) 7020 7021 7022 # LBHaeufigBegr.TextCtrl__li.nimmWert( 7023 # wert = werte[0][4] 7024 # , clientData = werte[0][3] ) 7025 # 7026 # LBHaeufigBegr.TextCtrl__re.nimmWert( 7027 # wert = werte[0][2] 7028 # , clientData = LBHaeufigBegr.TextCtrl__re.clientData ) 7029 7030 7031 # 7032 # -- 2.) Gefahrenstufe (im GUI angezeigt) ---------------------------------- 7033 # 7034 if( not istCBHaeufigAenderung ) : 7035 7036 LBGefStufeBegr.loescheAlles() 7037 LBGefStufeBegr.nimmWert( wert = werte[0][4] + '\t|\t' + werte[0][2] 7038 , clientData = [ werte[0][3] 7039 # -- >notizen< ------------------------- 7040 , werte[0][2] ] ) 7041 7042 # -- >prj.pp_psgefszenario.id< --------- 7043 #, self.__gibWert__( 0, 7 ) ] ) 7044 LBGefStufeBegr.SetSelection( 0 ) 7045 7046 7047 # LBGefStufeBegr.TextCtrl__li.nimmWert( 7048 # wert = werte[0][4] 7049 # , clientData = werte[0][3] ) 7050 # 7051 # LBGefStufeBegr.TextCtrl__re.nimmWert( 7052 # wert = werte[0][2] 7053 # , clientData = LBGefStufeBegr.TextCtrl__re.clientData ) 7054 7055 7056 # 7057 # -- 3.) Risikostufe (im GUI angezeigt) ---------------------------------- 7058 # 7059 7060 tmpZk = TCASRisikostufe.gibWert() 7061 7062 for k in range( TCASRisikostufe.gibAnzahl() ) : 7063 if TCASRisikostufe.gibClientData( k )[0] == werte[1][0]: break 7064 7065 TCASRisikostufe.setzeWert( k ) 7066 7067 LBRisikoStufeBegr.loescheAlles() 7068 LBRisikoStufeBegr.nimmWert( wert = werte[1][4] + '\t|\t' + werte[1][2] 7069 , clientData = [ werte[1][3] 7070 # -- >notizen< ------------------------- 7071 , werte[1][2] ] ) 7072 7073 # -- >prj.pp_psgefszenario.id< --------- 7074 #, self.__gibWert__( 0, 7 ) ] ) 7075 LBRisikoStufeBegr.SetSelection( 0 )

7076 7077 7078 7079 7080 # 7081 # ------------------------------------------------------------------------------------ 7082 # -- die zugeordnete Zeichenkette in >txtCtrlErg< eintragen, ------------------ 7083 # -- Tabellen >spr.*< auslesen ------------------ 7084 # ------------------------------------------------------------------------------------ 7085 #

7086 - def selektiere__sprSprachen( self, txtCtrlErg, sprUebvarId, sprSprachenId ):

7087 """ 7088 Methode zum Eintragen der Zeichenkette in das Texteingabefeld (C{TextCtrlErg / TextCtrlErg}), welche der aktuelle übergebenen C{sprUebvarId} in der gewählten Sprache (C{sprSprachenId}) zugeordnet ist. 7089 7090 @note: Das übergebene Texteingabefeld (C{TextCtrlErg / TextCtrlErg}) wird verändert ! 7091 7092 @param txtCtrlErg: Es ist das Texteingabefeld (C{TextCtrlErg / TextCtrlErg}) zu übergeben. 7093 @type txtCtrlErg: TextCtrlErg / TextCtrlErg 7094 @param sprUebvarId: Es ist die Datenbankidentifikationsnummer (C{spr.uebvar.id}) der Übersetzungsvariante zu übergeben. 7095 @type sprUebvarId: Ganzzahl 7096 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 7097 @type sprSprachenId: Ganzzahl 7098 """ 7099 7100 # 7101 # -- SQL-Abfrage ausführen -------------------------------------------------- 7102 # 7103 self.__dbAbfrage__( """ 7104 SELECT COALESCE( ( 7105 SELECT DISTINCT 7106 spr.zeige__wgruppe.wgruppe 7107 FROM 7108 spr.zeige__wgruppe 7109 WHERE 7110 -- Übersetzungsvariante angeben 7111 spr.zeige__wgruppe.spr_uebvar_id = """ + str( sprUebvarId ) + """ 7112 AND 7113 -- Sprache Auswählen 7114 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ 7115 ), '??' ) AS zk 7116 ;""" ) 7117 7118 7119 # 7120 # -- die gelesene Zeichenkette eintragen ---------------------------------- 7121 # 7122 txtCtrlErg.nimmWert( self.__gibWert__( 0, 0 ) )

7123 7124 7125 7126 7127 # 7128 # ------------------------------------------------------------------------------------ 7129 # -- die zugeordneten Strukturpunkte in >wxListBox<, -------------------------- 7130 # -- Tabelle >str.strkt< selektieren -------------------------- 7131 # ------------------------------------------------------------------------------------ 7132 #

7133 - def selektiere__strStrkt( self, wxListBox, prjProjekteId, strStrktId_li, strNameId_re ):

7134 """ 7135 Methode zur Selektion der Strukturpunkte in der Auswahlliste (C{wxListBox}), welche die im aktuell übergebenen Projekt, in der aktuell übergebenen Struktur (rechts) zum aktuell übergebenen Strukturpunkt (links) (darstellt). 7136 Personen werden nur dann selektiert, wenn ein Projekt (C{prjProjekteId > 0}) angegeben wurde. 7137 7138 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 7139 7140 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Strukturpunkte (rechts) enthält. 7141 @type wxListBox: wxPython - ListBox 7142 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 7143 @type prjProjekteId: Ganzzahl 7144 @param strStrktId_li: Es ist die Datenbankidentifikationsnummer (C{str.strkt.id}) des Strukturpunktes (links) zu übergeben, dessen zugeordneten Strukturpunkte (rechts) selektiert werden sollen. 7145 @type strStrktId_li: Ganzzahl 7146 @param strNameId_re: Es ist die Datenbankidentifikationsnummer (C{str.name.id}) der Strukturbezeichnung (rechts) zu übergeben, die die zugeordneten Strukturpunkte enthält. 7147 @type strNameId_re: Ganzzahl 7148 """ 7149 7150 # 7151 # SQL-Abfrage ausführen, 7152 # die gelesenen Werte der ListBox zuordnen 7153 # 7154 self.__dbAbfrage__( """ 7155 SELECT DISTINCT 7156 prj__p_strverbindung__str_strkt_id_nachf 7157 FROM 7158 prj.zeige__strstrkt 7159 , str.strkt 7160 WHERE 7161 -- 7162 -- Strukturpunkt (links) auswählen 7163 -- 7164 str__strkt__id = """ + str( strStrktId_li ) + """ 7165 AND 7166 -- 7167 -- Strukturnamen (rechts) auswählen 7168 -- 7169 prj__p_strverbindung__str_strkt_id_nachf = str.strkt.id 7170 AND 7171 str.strkt.str_name_id = """ + str( strNameId_re ) + """ 7172 AND 7173 -- 7174 -- Projekt auswählen 7175 -- 7176 prj_projekte_id = """ + str( prjProjekteId ) + """ 7177 AND 7178 prj__ppu_strstrkt__prj_projekte_id = prj__pu_strverbindung__prj_projekte_id 7179 ;""" ) 7180 7181 strStrktIdNachf = [] 7182 7183 for i in range( self.__gibAnzZeilen__() ) : 7184 strStrktIdNachf.append( self.__gibWert__( i, 0 ) ) 7185 7186 self.WxListBoxSelektieren( wxListBox, strStrktIdNachf )

7187 7188 7189 7190 7191 # 7192 # ------------------------------------------------------------------------------------ 7193 # -- PostgreSQL-Safepoint setzen ------------------------------------------ 7194 # ------------------------------------------------------------------------------------ 7195 #

7196 - def setzeSafepoint( self, name ):

7197 """ 7198 Methode zum setzen eines C{PostgreSQL - Safepoints}. Mittels C{Safepoint} können Teile einer Transaktion gespeichert oder verworfen werden. 7199 7200 @param name: Es ist der Name des C{Safepoints} anzugeben. Anhand des Namens können die Datenbankoperationen, welche nach dem Setzen des C{Safepoints} durchgeführt wurden übernommen oder verworfen werden. 7201 @type name: Zeichenkette 7202 """ 7203 7204 # 7205 # -- vorsichtshalber einen neuen Cursor anlegen -------------------------- 7206 # 7207 self.dbCursor = self.dbVerbindung.cursor() 7208 7209 # 7210 # -- SAFEPOINT setzen -------------------------------------------------- 7211 # 7212 self.__dbAbfrage__( 'SAVEPOINT ' + name + ';' ) 7213 7214 # 7215 # -- vorsichtshalber einen neuen Cursor anlegen -------------------------- 7216 # 7217 self.dbCursor = self.dbVerbindung.cursor()

7218 7219 7220 # 7221 # ------------------------------------------------------------------------------------ 7222 # -- Änderungen verwerfen (aktuelle Transaktion schließen, ------------------ 7223 # -- neue Transaktion starten) ------------------ 7224 # ------------------------------------------------------------------------------------ 7225 #

7226 - def verwerfeAenderungen( self ):

7227 """ 7228 Es werden alle Änderungen verworfen (der alte Datenbankzustand hergestellt), die laufende Transaktion beendet und eine neue Transaktion gestartet. 7229 """ 7230 7231 # 7232 # -- Änderungen verwerfen, Transaktion starten -------------------------- 7233 # 7234 self.dbVerbindung.rollback()

7235 7236 7237 7238 7239 7240 # 7241 # ------------------------------------------------------------------------------------ 7242 # -- Alle Änderungen seit Setzen eines PostgreSQL-Safepoints verwerfen -- 7243 # ------------------------------------------------------------------------------------ 7244 #

7245 - def verwerfeAenderungenSafepoint( self, name ):

7246 """ 7247 Methode zum Verwerfen der Änderungen, welche seit dem Setzen eines C{PostgreSQL - Safepoints} durchgeführt wurden. Mittels C{Safepoint} können Teile einer Transaktion gespeichert oder verworfen werden. 7248 7249 @param name: Es ist der Name des C{Safepoints} anzugeben. 7250 @type name: Zeichenkette 7251 """ 7252 7253 # 7254 # -- vorsichtshalber einen neuen Cursor anlegen -------------------------- 7255 # 7256 self.dbCursor = self.dbVerbindung.cursor() 7257 7258 # 7259 # -- bis zum SAFEPOINT zurückrollen ------------------------------------------ 7260 # 7261 self.__dbAbfrage__( 'ROLLBACK TO SAVEPOINT ' + name + ';' ) 7262 7263 # 7264 # -- vorsichtshalber einen neuen Cursor anlegen -------------------------- 7265 # 7266 self.dbCursor = self.dbVerbindung.cursor()

7267 7268 7269 # 7270 # ------------------------------------------------------------------------------------ 7271 # -- alle ListBox - Einträge deselktieren ---------------------------------- 7272 # ------------------------------------------------------------------------------------ 7273 #

7274 - def WxListBoxDeselektieren( self, wxListBox ):

7275 """ 7276 Methode, die alle Selektionen in der übergebenen C{wxListBox} zurücksetzt. 7277 7278 @note: Das übergebene C{wx-ListBox-Objekt} wird verändert ! Bisher gesetzte Selektionen werden zurückgesetzt. 7279 7280 @param wxListBox: Es ist das C{wx-ListBox-Objekt} zu übergeben. 7281 @type wxListBox: C{wx-ListBox-Objekt} 7282 """ 7283 7284 # 7285 # alle bisher gesetzten Selektionen ermitteln und zurücksetzen 7286 # 7287 tmp = wxListBox.GetSelections() 7288 7289 for i in range( len( tmp ) ) : 7290 wxListBox.Deselect( tmp[i] )

7291 7292 7293 # 7294 # ------------------------------------------------------------------------------------ 7295 # -- wxControlWithItems initialisieren ---------------------------------- 7296 # ------------------------------------------------------------------------------------ 7297 #

7298 - def WxListBoxSelektieren( self, wxListBox, listeId ):

7299 """ 7300 Interne Methode zur Selektion mehrerer Einträge eines C{wx-ListBox-Objektes}. Als Selektionskriterium wird der erste Eintrag im zugeordneten C{clienData-Objekt} verwendet. 7301 7302 @note: Das übergebene C{wx-ListBox-Objekt} wird verändert ! Bisher gesetzte Selektionen werden zurückgesetzt. 7303 7304 @param wxListBox: Es ist das C{wx-ListBox-Objekt} zu übergeben, welches die Einträge (einschl. gültigem C{clienData-Objekt}) enthält. 7305 @type wxListBox: C{wx-ListBox-Objekt} 7306 @param listeId: Es ist eine Liste mit Ganzzahlwerten zu übergeben, welche die Selektionskriterien enthält. 7307 @type listeId: C{Liste} 7308 """ 7309 7310 # 7311 # alle bisher gesetzten Selektionen ermitteln und zurücksetzen 7312 # 7313 self.WxListBoxDeselektieren( wxListBox ) 7314 7315 # 7316 # Listeneinträge selektieren 7317 # 7318 for i in range( wxListBox.GetCount() ): 7319 if listeId.count( wxListBox.GetClientData( i )[0] ) > 0 : 7320 wxListBox.SetSelection( i )

Source Code for Module datenbank