datenbank

135 """ 136 Klasse zum Datenbankzugriff auf PostgreSQL-Datenbanken. Es wird die Datenbankverbindung hergestellt und eine Transaktion gestartet. 137 138 @keyword dbName: Es ist der Datenbankname anzugeben 139 @type dbName: Zeichenkette 140 @keyword dbBenutzerName: Es ist der Datenbankbenutzername zu übergeben. 141 @type dbBenutzerName: Zeichenkette 142 @keyword dbKennwort: Es ist das Kennwort des Datenbankbenutzers zu übergeben. 143 @type dbKennwort: Zeichenkette 144 @keyword hostaddr: Es ist die IP-Adresse anzugeben, über die der PostgreSQL-Datenbankserver ansprechbar ist. 145 @type hostaddr: Zeichenkette 146 147 @raise Fehler: Fehlermeldung und Programmende, wenn die Datenbankverbindung nicht hergestellt werden kann. 148 """ 149 150 151 152 153 # 154 # ------------------------------------------------------------------------------------ 155 # ------------------------------------------------------------------------------------ 156 # -- Datenbankverbindung herstellen ---------------------------------- 157 # ------------------------------------------------------------------------------------ 158 # ------------------------------------------------------------------------------------ 159 #

160 - def __init__( self, dbName, dbBenutzerName, dbKennwort, hostaddr ):

161 162 # 163 # -------------------------------------------------------------------------------- 164 # -- Konstanten ---------------------------------------------------------- 165 # -------------------------------------------------------------------------------- 166 # 167 self.konstante__prt_typ_id__gefProt = range( 1, 20 ) 168 self.konstante__prt_typ_id__siAnf = range( 20, 28 ) 169 170 self.konstante__str_name_id__gefahrennetz = 2 171 172 173 174 # 175 # -------------------------------------------------------------------------------- 176 # -- Protokolldatei anlegen -------------------------------------------------- 177 # -------------------------------------------------------------------------------- 178 # 179 self.Protokolldatei = None 180 self.__ProtokolldateiEintrag__ = "" 181 182 183 # 184 # -------------------------------------------------------------------------------- 185 # -- Anzahl der gelesenen Spalten / Zeilen -------------------------- 186 # -- Wurden Werte zurückgegeben ? -------------------------- 187 # -- Cursorobjekt -------------------------- 188 # -- Objekt für die Abfrageergebnisse bereitstellen -------------------------- 189 # -------------------------------------------------------------------------------- 190 # 191 self.ps_gefszenario_id = None 192 """ 193 @cvar: Enthält die aktuelle C{ps.gefszenario.id}. 194 @type: Ganzzahl 195 """ 196 197 self.anzSpalten = 0 198 """ 199 @requires: Erst ist C{__dbAbfrage__(...)} auszuführen.. 200 201 @cvar: Enthält die Anzahl der gelesenen Spalten. 202 @type: Ganzzahl 203 """ 204 205 self.anzZeilen = 0 206 """ 207 @requires: Erst ist C{__dbAbfrage__(...)} auszuführen.. 208 209 @cvar: Enthält die Anzahl der gelesenen Zeilen (Tuples). 210 @type: Ganzzahl 211 """ 212 213 self.hatWerte = False 214 """ 215 @requires: Erst ist C{__dbAbfrage__(...)} auszuführen.. 216 217 @cvar: Die Datenbankabfrage hat Werte zurückgegeben. 218 @type: Boolean 219 """ 220 221 self.dbCursor = None 222 """ 223 @cvar: Datenbankobjekt, welches den systemweit geltenden Datenbankcursor repräsentiert. 224 @type: pgdb - Cursor Object 225 """ 226 227 self.__dbAbfrage__Ergebnis = None 228 """ 229 @cvar: Repräsentiert das Ergebnis der SQL-Abfrage. 230 @type: pgdb - Cursor Object 231 """ 232 233 234 235 # 236 # -------------------------------------------------------------------------------- 237 # -- Filterkriterien -------------------------------------------------- 238 # -------------------------------------------------------------------------------- 239 # 240 self.filter__prj_projekte_id = 2 241 """ 242 @cvar: Filter: Aktuell gewähltes Projekt. Die Projekte beginnen mit C{prj.projekte.id == 2}. 243 @type: Ganzzahl 244 """ 245 246 self.filter__spr_sprachen_id = 1 247 """ 248 @cvar: Filter: Aktuell gewählte Sprache 249 @type: Ganzzahl 250 """ 251 252 self.filter__zusKrit = dict() 253 """ 254 @cvar: Filter: Zusätzliche Filterkriterien 255 @type: Ganzzahl 256 """ 257 258 self.filter__bezeichnungAspekte = [ "-- Kein Aspekt gewählt --" 259 , "Strukturbezeichnung" # <- 1 260 , "Strukturpunkt" 261 , "Typ der Sicherheitsanforderung" # <- 3 262 , "Sicherheitsanforderung" 263 , "Typ des Protokolleintrages" # <- 5 264 , "Protokolleintrag" 265 , "Dokumentersteller (Firma)" # <- 7 266 , "Dokument" ] 267 """ 268 @cvar: Filter: Bezeichnung der Aspekte der weiteren Filterkriterien. 269 @type: Python-Liste 270 """ 271 272 273 # 274 # -------------------------------------------------------------------------------- 275 # -- Permanente Datenstrukturen ---------- 276 # -- Mehrfaches redundantes Aufrufen von SQL-Abfragen vermeiden ---------- 277 # -- (Zugriffszeit optimieren) ---------- 278 # -------------------------------------------------------------------------------- 279 # 280 281 # 282 # -- Formular 'Filter' -------------------------------------------------- 283 # 284 self.daten__prjProjekte = [] # ist unabhängig von Projekt/Sprache/Gefahrenszenario 285 self.daten__sprSprachen = [] # ist unabhängig von Projekt/Sprache/Gefahrenszenario 286 287 # 288 # -- Dokumente ---------------------------------------------------------- 289 # 290 self.daten__dokDoku__Projekt__Sprache = [] # ist unabhängig vom Gefahrenszenario 291 self.daten__internFirma = [] # ist unabhängig von Projekt/Sprache/Gefahrenszenario 292 self.daten__ProtId_DokuId__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszenario 293 294 # 295 # -- Gefahrenprotokolleinträge / Sicherheitsanforderungen ------------------ 296 # 297 self.daten__prjPersonen = [] # ist unabhängig von Projekt/Sprache/Gefahrenszenario 298 self.daten__prtTyp__Sprache = [] # ist unabhängig von Projekt/Gefahrenszenario 299 300 301 # 302 # -- Gefahrenprotokolleinträge ------------------------------------------ 303 # 304 self.daten__prtProtokoll_gefProt__Projekt__Sprache = dict() # ist unabhängig vom Gefahrenszenario 305 self.daten__prtProtokoll_gefProt_vorg__Projekt__Sprache = dict() # ist unabhängig von Sprache/Gefahrenszen. 306 self.daten__GefszenId_ProtId_gefProt__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszen. 307 308 self.daten__ProtId_PersId_aufgabe__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszen. 309 self.daten__ProtId_PersId_teilnehmer__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszen. 310 311 self.daten__ProtId_DatUhrz_aufgabe__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszen. 312 self.daten__ProtId_DatUhrz_teilnehmer__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszen. 313 314 315 # 316 # -- Gefahrenszenario -------------------------------------------------- 317 # 318 self.daten__psAbk__Projekt__Sprache = dict() # ist unabhängig vom Gefahrenszenario 319 self.daten__psAbk_Risikomatrix = dict() # ist unabhängig von Projekt/Sprache/Gefahrenszen. 320 321 self.daten__GefszenId_AbkId_gp__Projekt__Sprache = dict() # ist unabhängig von Gefahrenszen. 322 self.daten__GefszenId_AbkId_rh__Projekt__Sprache = dict() # ist unabhängig von Gefahrenszen. 323 self.daten__GefszenId_AbkId_rg__Projekt__Sprache = dict() # ist unabhängig von Gefahrenszen. 324 self.daten__GefszenId_AbkId_rr__Projekt__Sprache = dict() # ist unabhängig von Gefahrenszen. 325 326 self.daten__GefszenId_AnmId__Projekt__Sprache = dict() # ist unabhängig von Gefahrenszen. 327 self.daten__GefszenId_Wortgruppen__Projekt__Sprache = dict() # ist unabhängig von Gefahrenszen. 328 329 330 # 331 # -- Sicherheitsanforderungen ------------------------------------------ 332 # 333 self.daten__prtProtokoll_siAnf__Projekt__Sprache = dict() # ist unabhängig vom Gefahrenszenario 334 self.daten__prtProtokoll_siAnf_vorg__Projekt__Sprache = dict() # ist unabhängig von Sprache/Gefahrenszen. 335 self.daten__prtProtokoll_siAnf_gefProt__Projekt__Sprache = dict() # ist unabhängig von Sprache/Gefahrenszen. 336 self.daten__GefszenId_ProtId_siAnf__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszen. 337 338 339 # 340 # -- Struktur ---------------------------------------------------------- 341 # 342 self.daten__strName = [] # ist unabhängig von Projekt/Sprache/Gefahrenszenario 343 self.daten__strStrkt__Projekt__Sprache = [] # ist unabhängig vom Gefahrenszenario 344 345 self.daten__GefszenId_StruktId__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszenario 346 self.daten__ProtId_StruktId__Projekt = dict() # ist unabhängig von Sprache/Gefahrenszenario 347 348 349 350 # 351 # -------------------------------------------------------------------------------- 352 # -- Datenbankverbindung entsprechend ------------------ 353 # -- Python Database API Specification v2.0 (PEP: 249) ------------------ 354 # -------------------------------------------------------------------------------- 355 # 356 try: 357 self.dbVerbindung = pgdb.connect( database = dbName 358 , user = dbBenutzerName 359 , password = dbKennwort 360 , host = hostaddr ) 361 """ 362 @cvar: Datenbankobjekt, welches die Datenbankverbindung enthält. 363 @type: pgdb - Connection Object 364 """ 365 366 except pgdb.Error, msg: 367 raise Fehler( "Die Verbindung zum Datenbankserver (PostgreSQL) konnte nicht hergestellt werden.\n\n" + str( msg ) + "\n" + "'wxvf' wird beendet." ) 368 369 370 371 # 372 # -- Tabellen, die auf >spr.uebvar.id< referenzieren auslesen ---------- 373 # 374 self.listeTabellenSprUebvarId = self.__liesTabSpFremdschluessel__( zielSpalte = 'spr.uebvar.id' ) 375 """ 376 @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 ! 377 @type: Python-Liste 378 """ 379 380 381 # 382 # -- >spr.uebersetzung.spr_uebvar_id< entfernen -------------------------- 383 # 384 for i in range( len( self.listeTabellenSprUebvarId ) ) : 385 386 if( self.listeTabellenSprUebvarId[i][0] == 'spr.uebersetzung' ) : 387 388 del self.listeTabellenSprUebvarId[i] 389 break

390 391 392 393 394 395 396 # 397 # ------------------------------------------------------------------------------------ 398 # ------------------------------------------------------------------------------------ 399 # -- Datenbankabfrage -------------------------------------------------- 400 # ------------------------------------------------------------------------------------ 401 # ------------------------------------------------------------------------------------ 402 #

403 - def __dbAbfrage__( self, sql ):

404 """ 405 Methode zur Datenbankabfrage (die mittels C{sql} übergebenen SQL-Abfrage ausführen). 406 407 @param sql: Es ist die SQL-Abfrage zu übergeben. 408 @type sql: Zeichenkette 409 410 @raise Fehler: Fehlermeldung, wenn die SQL-Abfrage nicht erfolgreich war. 411 """ 412 413 # 414 # -- die internen Parameter zurücksetzen ---------------------------------- 415 # 416 self.anzSpalten = 0 417 self.anzZeilen = 0 418 self.hatWerte = False 419 self.__dbAbfrage__Ergebnis = None 420 421 422 423 # 424 # -- >sql< darf nicht leer oder >None< sein ---------------------------------- 425 # 426 if( sql is None 427 or len( sql ) == 0 ) : 428 429 return 430 431 432 433 # 434 # -- CURSOR bereitstellen -------------------------------------------------- 435 # 436 if( self.dbCursor == None ) : self.dbCursor = self.dbVerbindung.cursor() 437 438 439 # 440 # -- Datenbank abfragen, ------------------------------------------ 441 # -- Datenbankabfrageobjekt anlegen ------------------------------------------ 442 # 443 try: 444 445 # 446 # -- SQL-Abfrage ausführen ------------------------------------------ 447 # 448 # 449 # fortsetzen 450 # 451 # self.ProtokolldateiEintragen( eintrag = sql ) 452 self.dbCursor.execute( sql ) 453 454 455 456 # 457 # -- für SQL-Abfragen, die keine Zeilen liefern (BEGIN, ...) ---------- 458 # 459 self.hatWerte = not( self.dbCursor.description == None ) 460 if( not self.hatWerte ) : 461 return 462 463 # -- Notlösung -------------------------------------------------- 464 if( sql.find( "SAVEPOINT" ) > -1 ) : return 465 466 467 468 self.__dbAbfrage__Ergebnis = self.dbCursor.fetchall() 469 470 471 # 472 # -- für SELECT-Abfragen, die keine Zeilen liefern ------------------ 473 # 474 self.hatWerte = not( self.__dbAbfrage__Ergebnis == [] ) 475 if( not self.hatWerte ) : 476 return 477 478 479 except pgdb.Error, msg: 480 raise Fehler( msg ) 481 482 483 # 484 # -- Zeilenanzahl, Spaltenanzahl übernehmen ---------------------------------- 485 # 486 self.anzSpalten = len( self.dbCursor.description ) 487 self.anzZeilen = self.dbCursor.rowcount

488 489 490 491 # 492 # ------------------------------------------------------------------------------------ 493 # ------------------------------------------------------------------------------------ 494 # -- Spaltenanzahl zurückgeben ------------------------------------------ 495 # ------------------------------------------------------------------------------------ 496 # ------------------------------------------------------------------------------------ 497 #

498 - def __gibAnzSpalten__( self ):

499 """ 500 Methode die die Anzahl der gelesenen Spalten der C{__dbAbfrage__( ..., lfdNr )} zurückgibt. 501 502 @requires: Erst ist C{__dbAbfrage__( ..., lfdNr )} auszuführen. 503 504 @return: Es wird die Spaltenanzahl zurückgegeben. 505 @rtype: Ganzzahl 506 """ 507 508 # 509 # -- Spaltenanzahl zurückgeben ------------------------------------------ 510 # 511 return self.anzSpalten

512 513 514 515 516 # 517 # ------------------------------------------------------------------------------------ 518 # ------------------------------------------------------------------------------------ 519 # -- Zeilenanzahl zurückgeben ------------------------------------------ 520 # ------------------------------------------------------------------------------------ 521 # ------------------------------------------------------------------------------------ 522 #

523 - def __gibAnzZeilen__( self ):

524 """ 525 Methode die die Anzahl der gelesenen Zeilen der C{__dbAbfrage__( ..., lfdNr )} zurückgibt. 526 527 @requires: Erst ist C{__dbAbfrage__( ..., lfdNr )} auszuführen. 528 529 @return: Es wird die Zeilenanzahl zurückgegeben. 530 @rtype: Ganzzahl 531 """ 532 533 # 534 # -- Zeilenanzahl zurückgeben ------------------------------------------ 535 # 536 return self.anzZeilen

537 538 539 540 541 # 542 # ------------------------------------------------------------------------------------ 543 # ------------------------------------------------------------------------------------ 544 # -- ID's der zusätzlichen Filterkriterien zurückgeben ------------------ 545 # ------------------------------------------------------------------------------------ 546 # ------------------------------------------------------------------------------------ 547 #

548 - def __gibFilterZusKrit__Id__( self, filterKrit ):

549 """ 550 Methode, die die Datenbank-Id in Abhängigkeit von den gewählten Filterkriterien C{filterKrit} zurückgibt. 551 552 @param filterKrit: Es ist das Filterkriterium entsprechend der in C{wxuniversal.py} definierten Konstanten C{HK_xxx} zu übergeben. 553 @type filterKrit: Zeichenkette 554 555 @return: Es wird die Liste der ausgewählten Datenbank-Id als Zeichenkette zurückgegeben. Wurde kein Filterkriterium gewählt wird eine Leerzeichenkette zurückgegeben. 556 @rtype: Zeichenkette 557 """ 558 559 # 560 # -- Es liegt keine Filterbedingung zu den zulässigen Aspekten vor ---------- 561 # 562 if( len( self.filter__zusKrit ) == 0 ) : 563 564 return "" 565 566 567 568 # 569 # -- Liste der gewählten Id zurückgeben ---------------------------------- 570 # 571 erg = [] 572 for i in self.filter__zusKrit.iteritems() : 573 574 if( i[0].find( filterKrit ) != 0 ) : 575 576 continue 577 578 erg.append( i[1] ) 579 580 if( len( erg ) > 0 ) : return str( erg ).replace( '[', '' ).replace( ']', '' ) 581 582 583 584 # 585 # -- Es wurde eine ungültige Filterbedingung gewählt ------------------ 586 # 587 return ""

588 589 590 591 592 # 593 # ------------------------------------------------------------------------------------ 594 # ------------------------------------------------------------------------------------ 595 # -- >ps.gefszenario.id< die den zusätzlichen -------------------------- 596 # -- Filterkriterien genügen, zurückgeben -------------------------- 597 # ------------------------------------------------------------------------------------ 598 # ------------------------------------------------------------------------------------ 599 #

600 - def __gibFilterZusKrit__PsGefszenarioId__( self ):

601 """ 602 Es werden die C{ps.gefszenario.id} zurückgegeben, die den zusätzlichen Filterkriterien genügen. 603 604 @return: Es wird die Liste der C{ps.gefszenario.id} zurückgegeben, die den zusätzlichen Filterkriterien genügt (genügt kein Gefahrenszenario den zusätzlichen Filterkriterien, wird eine Leerzeichenkette zurückgegeben). Wurden keine zusätzlichen Filterkriterien angegeben, wird C{None} zurückgegeben. 605 @rtype: Zeichenkette 606 """ 607 608 # 609 # -- Es wurden keine zusätzlichen Filterkriterien ausgewählt ---------- 610 # 611 if( len( self.filter__zusKrit ) == 0 ) : 612 613 return None 614 615 616 617 # 618 # -- Typen der gewählten Filterkriterien zusammenstellen ------------------ 619 # -- (Duplikate entfernen) ------------------ 620 # 621 setFilterZusKrit__Typ = set() 622 for i in self.filter__zusKrit.iteritems() : 623 624 tmp = i[0].partition( '|' )[0] 625 626 if( tmp == HK_INTERNFIRMA ) : tmp = HK_DOK 627 elif( tmp == HK_PETYP ) : tmp = HK_PE 628 elif( tmp == HK_SIANFTYP ) : tmp = HK_SIANF 629 elif( tmp == HK_STRBEZ ) : tmp = HK_STR 630 631 setFilterZusKrit__Typ.add( tmp ) 632 633 634 635 # 636 # -- gewählte Filterkriterien durchlaufen -- 637 # -- bereinigte Liste der gültigen >prt.protokoll.id< zusammenstellen -- 638 # 639 setFilterZusKrit__PrtProtokollId = set() 640 ersterDurchlauf = True 641 for i in setFilterZusKrit__Typ : 642 643 aktDaten = None 644 645 # 646 # -- Dokument(e) gewählt ------------------------------------------ 647 # -- Firma(en) gewählt ------------------------------------------ 648 # 649 if( i == HK_DOK ) : 650 651 aktDaten = self.daten__ProtId_DokuId__Projekt 652 653 # 654 # -- Protokolleinträge gewählt ---------------------------------- 655 # -- Typ der Protokolleinträge gewählt -------------------------- 656 # 657 elif( i == HK_PE ) : 658 659 aktDaten = self.daten__prtProtokoll_gefProt__Projekt__Sprache 660 661 # 662 # -- Sicherheitsanforderungen gewählt -------------------------- 663 # -- Typ der Sicherheitsanforderungen gewählt ------------------ 664 # 665 elif( i == HK_SIANF ) : 666 667 aktDaten = self.daten__prtProtokoll_siAnf__Projekt__Sprache 668 669 # 670 # -- Strukturpunkt(e) gewählt ---------------------------------- 671 # -- Strukturbezeichnung(en) gewählt ---------------------------------- 672 # 673 elif( i == HK_STR ) : 674 675 aktDaten = self.daten__ProtId_StruktId__Projekt 676 677 # 678 # -- sollte eigentlich nicht passieren -------------------------- 679 # 680 else : continue 681 682 683 # 684 # -- im ersten Durchlauf alle >prt.protkoll.id< übernehmen ---------- 685 # 686 if( ersterDurchlauf ) : 687 688 setFilterZusKrit__PrtProtokollId = set( aktDaten.keys() ) 689 690 ersterDurchlauf = False 691 692 continue 693 694 695 # 696 # -- in den weiteren Durchläufen alle >prt.protkoll.id< reduzieren -- 697 # 698 setFilterZusKrit__PrtProtokollId = setFilterZusKrit__PrtProtokollId.intersection( set( aktDaten.keys() ) ) 699 700 701 702 # 703 # -- keine >prt.protkoll.id< genügt den Filterkriterien ------------------ 704 # 705 if( len( setFilterZusKrit__PrtProtokollId ) == 0 ) : 706 707 return "" 708 709 710 # 711 # -- Gefahrenprotokoll-Id / Sicherheitsanforderungen-Id ------------------ 712 # -- ------------------ 713 # -- die Liste der >ps.gefszenario.id< zusammenstellen, die ------------------ 714 # -- den zusätzlichen Filterkriterien genügt ------------------ 715 # 716 erg = set() 717 718 tmp = [] 719 tmp.append( self.daten__GefszenId_ProtId_gefProt__Projekt ) 720 tmp.append( self.daten__GefszenId_ProtId_siAnf__Projekt ) 721 722 for i in tmp : 723 724 for j in i.iteritems() : 725 726 for k in j[1] : 727 728 if( k[0] in setFilterZusKrit__PrtProtokollId ) : 729 730 erg.add( j[0] ) 731 break 732 733 return str( erg ).replace( 'set([', '' ).replace( '])', '' )

734 735 736 737 738 739 # 740 # ------------------------------------------------------------------------------------ 741 # ------------------------------------------------------------------------------------ 742 # -- Werte zurückgeben -------------------------------------------------- 743 # ------------------------------------------------------------------------------------ 744 # ------------------------------------------------------------------------------------ 745 #

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

747 """ 748 Methode zur Rückgabe des gelesenen Wertes, der mittels C{zeilenNr, spaltenNr} angegeben wird. 749 Wenn aus der Datenbank C{NULL} gelesen wird, wird eine leere Zeichenkette zurückgegeben. 750 751 @requires: Erst ist C{__dbAbfrage__(...)} auszuführen.. 752 753 @param zeilenNr: Es ist die Zeilennummer zu übergeben. 754 @type zeilenNr: Ganzzahl 755 756 @param spaltenNr: Es ist die Spaltennummer zu übergeben. 757 @type spaltenNr: Ganzzahl 758 759 @return: Es wird der gelesenen Wert zurückgegeben. 760 @rtype: Datentyp des jeweiligen Wertes 761 """ 762 763 # 764 # -- keine Werte vorhanden -------------------------------------------------- 765 # 766 if( not self.__hatWerte__() 767 or zeilenNr > self.__gibAnzZeilen__() 768 or spaltenNr > self.__gibAnzSpalten__() ) : 769 return "" 770 771 772 # 773 # -- NULL vorhanden ---------------------------------------------------------- 774 # 775 if( len( self.__dbAbfrage__Ergebnis ) == 0 ) : 776 return "" 777 778 if( self.__dbAbfrage__Ergebnis[zeilenNr][spaltenNr] == None ) : 779 return "" 780 781 782 # 783 # -- Werte zurückgeben -------------------------------------------------- 784 # 785 if( isinstance( "Zk", type( self.__dbAbfrage__Ergebnis[zeilenNr][spaltenNr] ) ) ) : 786 787 if( os.name == 'nt' ) : 788 return unicode( self.__dbAbfrage__Ergebnis[zeilenNr][spaltenNr], 'utf-8' ).encode('windows-1252') 789 else : 790 return unicode( self.__dbAbfrage__Ergebnis[zeilenNr][spaltenNr], 'utf-8' ).encode('utf-8') 791 792 else: 793 794 return self.__dbAbfrage__Ergebnis[zeilenNr][spaltenNr]

795 796 797 798 799 # 800 # ------------------------------------------------------------------------------------ 801 # ------------------------------------------------------------------------------------ 802 # -- Die SQL-Abfrage hat Werte zurückgegeben -------------------------- 803 # ------------------------------------------------------------------------------------ 804 # ------------------------------------------------------------------------------------ 805 #

806 - def __hatWerte__( self ):

807 """ 808 Die C{__dbAbfrage__( ..., lfdNr )} hat Werte zurückgegeben. 809 810 @requires: Erst ist C{__dbAbfrage__( ..., lfdNr )} auszuführen. 811 812 @return: Es wird C{True} zurückgegeben, wenn die C{__dbAbfrage__( ..., lfdNr )} Werte zurückgegeben hat. 813 @rtype: Boolean 814 """ 815 816 # 817 # -- Zeilenanzahl zurückgeben ------------------------------------------ 818 # 819 return self.hatWerte

820 821 822 823 824 825 826 827 # 828 # ------------------------------------------------------------------------------------ 829 # ------------------------------------------------------------------------------------ 830 # -- Permanente Datenstrukturen initialisieren -------------------------- 831 # ------------------------------------------------------------------------------------ 832 # ------------------------------------------------------------------------------------ 833 #

834 - def __initPermDatenstruktur__( self, protokollDatKopf, sql, permDaten, istDict = False ):

835 """ 836 Interne Methode zur Initialisierung eines C{wx-Objektes}, welches eine Listenform hat. Die SQL-Abfrage wird nur dann ausgeführt, wenn die zu bearbeitende globale Variable C{permDaten} nicht C{None} ist. 837 838 @note: C{permDaten} und das übergebene C{wx-Objekt} wird verändert ! 839 840 @param protokollDatKopf: Es ist der Text der Kopfzeile der aktuellen SQL-Abfrage anzugeben, der in die Protokolldatei bei Ausführung der SQL-Abfrage geschrieben wird. 841 @type protokollDatKopf: Zeichenkette 842 843 @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 wxObjekt dargestellt wird. In den nächsten Spalten können zusätzliche (nicht sichtbare) Werte übergeben werden. 844 @type sql: Zeichenkette 845 846 @param permDaten: Es ist die globale Variable zu übergeben, die das Ergenis der SQL-Abfrage C{sql} aufnimmt. 847 @type permDaten: Liste / Dictionary 848 849 @param istDict: Es ist C{True} anzugeben, wenn C{permDaten} ein Python-Dictionary (Dict) ist. 850 @type istDict: Boolean 851 """ 852 853 # 854 # -------------------------------------------------------------------------------- 855 # -- die globale Variable muß mit Werten gefüllt werden ------------------ 856 # -- (Datenbankabfrage durchführen) ------------------ 857 # -------------------------------------------------------------------------------- 858 # 859 if( len( permDaten ) == 0 ) : 860 861 # 862 # -- in Protokolldatei schreiben ---------------------------------- 863 # 864 self.ProtokolldateiEintragen( eintrag = protokollDatKopf 865 , istKopfzeile = True ) 866 867 868 # 869 # -- SQL-Abfrage ausführen ------------------------------------------ 870 # 871 self.__dbAbfrage__( sql ) 872 873 874 # 875 # -- Dictionary schützen ------------------------------------------ 876 # 877 if( istDict and self.__gibAnzSpalten__() < 2 ) : 878 879 return 880 881 882 # 883 # -- Das Ergebnis der SQL-Abfrage in die globale Variable übernehmen -- 884 # 885 tmp = [] 886 akt = None 887 for i in range( self.__gibAnzZeilen__() ): 888 889 # 890 # -- Dictionary -------------------------------------------------- 891 # 892 if( istDict ) : 893 894 if( akt != self.__gibWert__( i, 0 ) ) : 895 896 tmp = [] 897 akt = self.__gibWert__( i, 0 ) 898 899 tmpZ = [] 900 for j in range( 1, self.__gibAnzSpalten__() ): 901 902 # tmp.append( self.__gibWert__( i, j ) ) 903 tmpZ.append( self.__gibWert__( i, j ) ) 904 905 tmp.append( tmpZ ) 906 permDaten[akt] = tmp 907 908 909 # 910 # -- Liste ---------------------------------------------------------- 911 # 912 else : 913 tmp = [] 914 for j in range( self.__gibAnzSpalten__() ): 915 916 tmp.append( self.__gibWert__( i, j ) ) 917 918 permDaten.append( tmp )

919 920 921 922 923 # 924 # ------------------------------------------------------------------------------------ 925 # ------------------------------------------------------------------------------------ 926 # -- wxControlWithItems initialisieren ---------------------------------- 927 # ------------------------------------------------------------------------------------ 928 # ------------------------------------------------------------------------------------ 929 #

930 - def __initWxControlWithItems__( self, sql, eintragNull, wxObj, formatiereWert = 0 ):

931 """ 932 Interne Methode zur Initialisierung eines C{wx-Objektes}, welches eine Listenform hat. 933 934 @note: Das übergebene C{wx-Objekt} wird verändert ! 935 936 @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. 937 @type sql: Zeichenkette 938 939 @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 940 @type eintragNull: Liste 941 942 @param wxObj: Es ist das C{wx-Objekt} zu übergeben, welches Datenbankwerte aufnimmt (darstellt). 943 @type wxObj: C{wx-Objekt} 944 945 @param formatiereWert: Es ist der Formatierungsparameter für den im C{wx-Objekt} dargestellten Wert zu übergeben. Es bedeuten C{0 ... keine Formatierung}, C{1 ... Zahlenwert: Führende Nullen bei vierstelligen Werten} 946 @type formatiereWert: C{wx-Objekt} 947 """ 948 949 950 # 951 # Datenbank abfragen, wxObj initialisieren 952 # 953 if len( eintragNull ) == 2: 954 wxObj.nimmWert( wert = eintragNull[0], clientData = eintragNull[1] ) 955 956 self.__dbAbfrage__( sql ) 957 958 for i in range( self.__gibAnzZeilen__() ): 959 clientData = [] 960 961 for j in range( 1, self.__gibAnzSpalten__() ): 962 clientData.append( self.__gibWert__( i, j ) ) 963 964 if( formatiereWert == 1 ) : 965 wxObj.nimmWert( wert = zk.gibIdWertNotizen( id = self.__gibWert__( i, 0 ), zusInfo = "" ) 966 , clientData = clientData ) 967 else : 968 wxObj.nimmWert( wert = str( self.__gibWert__( i, 0 ) ), clientData = clientData )

969 970 971 972 973 974 # 975 # ------------------------------------------------------------------------------------ 976 # ------------------------------------------------------------------------------------ 977 # -- Tabellen-, Spaltenname entsprechend Fremdschlüsseldefinition ---------- 978 # -- zurückgeben ---------- 979 # ------------------------------------------------------------------------------------ 980 # ------------------------------------------------------------------------------------ 981 #

982 - def __liesTabSpFremdschluessel__( self, zielSpalte ):

983 """ 984 Es wird die Liste der Tabellen- und Spaltennamen die auf C{zielSpalte} referenzieren. 985 986 @param zielSpalte: Es ist der vollständige Datenbankspaltenname anzugeben, auf den mittels Fremdschlüssel verwiesen wird. 987 @type zielSpalte: Zeichenkette 988 989 @return: Es wird die Liste C{[Tabellenname, Spaltenname]} zurückgegeben. 990 @rtype: Ganzzahl 991 """ 992 993 # 994 # -- Datenbank auslesen -------------------------------------------------- 995 # 996 self.__dbAbfrage__( """ 997 -- 998 -- Liste der Spaltenabhängigkeiten auslesen 999 -- 1000 SELECT 1001 intern.gib__stsname( 'schtab', spstart ) AS schtab 1002 , intern.gib__stsname( 'sp', spstart ) AS sp 1003 FROM 1004 intern.zeige__fremdschluessel 1005 WHERE 1006 spziel = '""" + zielSpalte + """' 1007 ;""" ) 1008 1009 1010 # 1011 # -- Abfrageergebnis zusammenstellen ---------------------------------- 1012 # 1013 erg = [] 1014 for i in range( self.__gibAnzZeilen__() ): 1015 1016 erg.append( [ self.__gibWert__( i, 0 ) 1017 , self.__gibWert__( i, 1 ) ] ) 1018 1019 1020 # 1021 # -- Liste zurückgeben -------------------------------------------------- 1022 # 1023 return erg

1024 1025 1026 1027 1028 # 1029 # ------------------------------------------------------------------------------------ 1030 # ------------------------------------------------------------------------------------ 1031 # -- SQL-Abfrage zur Selektion der Strukturpunkte -------------------------- 1032 # ------------------------------------------------------------------------------------ 1033 # ------------------------------------------------------------------------------------ 1034 #

1035 - def __gibSQL_prjPlPrtPsGefszenario__( self, psGefszenarioId = None, sqlINpsGefszenId = True ):

1036 """ 1037 Methode, die die SQL-Abfrage zurückgibt, die die Protokolleinträge auswählt, die dem Gefahrenszenario / weiteren Gefahrenszenarien im Projekt zugeordnet sind. 1038 1039 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 1040 @type psGefszenarioId: Ganzzahl 1041 1042 @param internFirmaId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 1043 @type internFirmaId: Ganzzahl 1044 1045 @param sqlINpsGefszenId: Wenn C{True} angegeben wird, werden die Protokolleinträge zum Gefahrenszenario ausgewählt. Sonst nicht. 1046 @type sqlINpsGefszenId: Boolean 1047 """ 1048 1049 # 1050 # -- SQL-Abfrage zurückgeben ------------------------------------------ 1051 # 1052 sqlNOT = '' 1053 if( not sqlINpsGefszenId ) : sqlNOT = 'NOT ' 1054 1055 sqlGefszenario = "" 1056 if( psGefszenarioId is not None ) : 1057 1058 sqlGefszenario = (""" 1059 AND 1060 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id """ + sqlNOT + """IN( """ 1061 + str( psGefszenarioId ) + """ )""") 1062 1063 return( """ 1064 SELECT DISTINCT 1065 prt_protokoll_id 1066 FROM 1067 prj.zeige__pl_prtpsgefszenario 1068 , prj.zeige__pl_prtpsgefszenario_le 1069 WHERE 1070 prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id = 1071 prj.zeige__pl_prtpsgefszenario.id 1072 AND 1073 prj.zeige__pl_prtpsgefszenario.logentfernt = false 1074 AND 1075 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ 1076 + str( self.filter__prj_projekte_id ) 1077 + sqlGefszenario + """ 1078 ;""" )

1079 1080 # 1081 # -- später einführen -------------------------------------------------- 1082 # 1083 # return( self.__gibSQLSelect__( 1084 # select = """ 1085 #SELECT DISTINCT 1086 # prt_protokoll_id""" 1087 # , tabellen = [ self.__gibSQLSelect__PlPrtPsGefszenario__( sqlJOIN = None 1088 # , sqlWHERE = """ 1089 #AND 1090 # prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id """ + sqlNOT + """IN( """ 1091 # + str( psGefszenarioId ) + """ ) 1092 #AND 1093 # prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) ) ] ) ) 1094 1095 1096 1097 1098 1099 # 1100 # ------------------------------------------------------------------------------------ 1101 # ------------------------------------------------------------------------------------ 1102 # -- SQL-Abfrage zur Selektion der Abkürzungen -------------------------- 1103 # ------------------------------------------------------------------------------------ 1104 # ------------------------------------------------------------------------------------ 1105 #

1106 - def __gibSQL_prjPlPsGefabk__( self ):

1107 """ 1108 Methode, die die SQL-Abfrage zurückgibt, die Abkürzungen auswählt, die dem Gefahrenszenario im Projekt zugeordnet sind. 1109 """ 1110 1111 # 1112 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 1113 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 1114 # 1115 if( self.ps_gefszenario_id is None ) : 1116 1117 return None 1118 1119 1120 1121 # 1122 # -- SQL-Abfrage zurückgeben ------------------------------------------ 1123 # 1124 return(""" 1125 -- 1126 -- Abkürzungen - es wird der jeweils letzte zugeordnete Eintrag angezeigt 1127 -- (Logbuchfunktion) 1128 -- 1129 SELECT 1130 -- 0 1131 prj.zeige__psabk.ps__abk__typ AS abk_typ 1132 , prj.zeige__pl_psgefabk.ps_abk_id AS abk_id 1133 -- 2 1134 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS begr 1135 , prj.zeige__pl_psgefabk.notizen 1136 -- 4 1137 , prj.zeige__pl_psgefabk.spr_uebvar_id_zus 1138 -- 1139 -- Kontrolle 1140 -- 1141 --, prj.zeige__pl_psgefabk.logdatuhrz AS datuhrz 1142 FROM 1143 prj.zeige__pl_psgefabk_le 1144 , prj.zeige__pl_psgefabk 1145 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 1146 prj.zeige__pl_psgefabk.spr_uebvar_id_zus = 1147 spr.zeige__wgruppe.spr_uebvar_id 1148 AND 1149 -- 1150 -- Sprache Auswählen 1151 -- 1152 spr.zeige__wgruppe.spr_sprachen_id = """ 1153 + str( self.filter__spr_sprachen_id ) + """ 1154 ) 1155 , prj.zeige__psabk 1156 WHERE 1157 -- 1158 -- Ausschließlich die letzten (aktuellen) Abkürzungen anzeigen, ... 1159 -- 1160 prj.zeige__pl_psgefabk_le.prj__pl_psgefabk__id = 1161 prj.zeige__pl_psgefabk.id 1162 AND 1163 -- 1164 -- ... die nicht entfernt wurden 1165 -- 1166 prj.zeige__pl_psgefabk.logentfernt = false 1167 AND 1168 -- 1169 -- Projekt auswählen 1170 -- 1171 prj.zeige__pl_psgefabk.prj_projekte_id = """ 1172 + str( self.filter__prj_projekte_id ) + """ 1173 AND 1174 -- 1175 -- Gefahrenszenario auswählen 1176 -- 1177 prj.zeige__pl_psgefabk.ps_gefszenario_id = """ + str( self.ps_gefszenario_id ) + """ 1178 AND 1179 -- 1180 -- Typ der Abkürzung zuordnen 1181 -- 1182 prj.zeige__pl_psgefabk.ps_abk_id = prj.zeige__psabk.ps__abk__id 1183 AND 1184 prj.zeige__pl_psgefabk.prj_projekte_id = 1185 prj.zeige__psabk.prj__p_psabk__prj_projekte_id 1186 ORDER BY 1187 prj.zeige__psabk.ps__abk__typ 1188 ;""")

1189 1190 1191 1192 1193 1194 1195 1196 1197 # 1198 # ------------------------------------------------------------------------------------ 1199 # ------------------------------------------------------------------------------------ 1200 # -- SQL-Abfrage zur Selektion der Dokumente -------------------------- 1201 # ------------------------------------------------------------------------------------ 1202 # ------------------------------------------------------------------------------------ 1203 #

1204 - def __gibSQL_prjPrtDoku__( self, prjProjekteId, sprSprachenId, prtProtokollId, internFirmaId, dokDokuId = None, ignorierePsGefszenarioId = False ):

1205 """ 1206 Methode, die die SQL-Abfrage zurückgibt, die die Dokumente auswählt, die einem Protokolleintrag, einer Sicherheitsanforderung, Terminplaneintrag oder Gefarenszenario zugeordnet sind. 1207 1208 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 1209 @type prjProjekteId: Ganzzahl 1210 1211 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 1212 @type sprSprachenId: Ganzzahl 1213 1214 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 1215 @type prtProtokollId: Ganzzahl 1216 1217 @param internFirmaId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 1218 @type internFirmaId: Ganzzahl 1219 1220 @param dokDokuId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 1221 @type dokDokuId: Ganzzahl 1222 1223 @param ignorierePsGefszenarioId: Es ist die C{True} anzugeben, wenn C{self.ps_gefszenario_id} in der SQL-Abfrage berücksichtigt werden soll. 1224 @type ignorierePsGefszenarioId: Boolean 1225 """ 1226 1227 # 1228 # Diese Routine muß beschleunigt werden ! 1229 # Sie gibt in >bearbeitedokumente.py< für die Projektübergreifenden Dokumente das falsche Ergebnis ! 1230 # 1231 1232 # 1233 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 1234 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 1235 # 1236 if( self.ps_gefszenario_id is None 1237 and not ignorierePsGefszenarioId ) : 1238 1239 return None 1240 1241 1242 # 1243 # -- Gefahrenszenario-Id ignorieren ---------------------------------- 1244 # 1245 psGefszenarioId = self.ps_gefszenario_id 1246 if( ignorierePsGefszenarioId ) : psGefszenarioId = None 1247 1248 1249 1250 # 1251 # -- SQL-Abfrageergebnis einschränken ---------------------------------- 1252 # 1253 projekt = "" 1254 protokoll = "" 1255 gefszenario = "" 1256 firma = "" 1257 doku = "" 1258 1259 if( prjProjekteId is not None ) : 1260 projekt = """ 1261 AND 1262 -- 1263 -- Projekt festlegen 1264 -- 1265 prj.zeige__dokdoku.prj__pl_prtdokdoku__prj_projekte_id = """ + str( prjProjekteId ) + """ 1266 """ 1267 1268 if( prtProtokollId is not None ) : 1269 protokoll = """ 1270 AND 1271 -- 1272 -- Protokolleinträge festlegen 1273 -- 1274 prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id IN( """ + str( prtProtokollId ) + """ ) 1275 """ 1276 1277 if( psGefszenarioId is not None ) : 1278 gefszenario = """ 1279 AND 1280 -- 1281 -- Gefahrenszenarien festlegen 1282 -- 1283 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id = """ + str( psGefszenarioId ) + """ 1284 """ 1285 1286 if( internFirmaId is not None ) : 1287 firma = """ 1288 AND 1289 -- 1290 -- Firma einschränken 1291 -- 1292 prj.zeige__dokdoku.dok__doku__intern_firma_id = """ + str( internFirmaId ) + """ 1293 """ 1294 1295 if( dokDokuId is not None ) : 1296 doku = """ 1297 AND 1298 -- 1299 -- Dokument einschränken 1300 -- 1301 prj.zeige__dokdoku.dok__doku__id = """ + str( dokDokuId ) + """ 1302 """ 1303 1304 1305 return( """ 1306 -- 1307 -- Dokumente anzeigen 1308 -- 1309 SELECT DISTINCT 1310 -- 0 1311 prj.zeige__dokdoku.dok__doku__id 1312 , prj.zeige__dokdoku.dok__doku__notizen AS dok_notizen 1313 -- 2 1314 , prj.zeige__dokdoku.prj__pl_prtdokdoku__nr 1315 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS titel 1316 -- 4 1317 , prj.zeige__dokdoku.prj__pl_prtdokdoku__notizen AS prj_notizen 1318 , ausgabe.prj__pl_dokausgabe__stand AS stand 1319 -- 6 1320 , to_char( ausgabe.prj__pl_dokausgabe__datum, 'DD.MM.YYYY' ) AS datum 1321 , ausgabe.prj__pl_dokausgabe__notizen AS ausg_notizen 1322 -- 8 1323 , prj.zeige__dokdoku.dok__doku__aspekt AS dok_aspekt 1324 , COALESCE( zus.wgruppe, '??' ) AS zus 1325 -- 10 1326 , prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id 1327 , prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id_zus 1328 -- 12 1329 , ausgabe.prj__pl_dokausgabe__istfrei AS istfrei 1330 , prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id 1331 -- 14 1332 , prj.zeige__dokdoku.dok__doku__spr_uebvar_id_kb 1333 , prj.zeige__dokdoku.dok__doku__intern_firma_id 1334 FROM 1335 prj.zeige__pl_prtpsgefszenario 1336 , prj.zeige__pl_prtpsgefszenario_le 1337 , prj.zeige__pl_prtdokdoku_le 1338 , prj.zeige__dokdoku 1339 -- 1340 -- Dokumententitel 1341 -- 1342 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 1343 prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id = 1344 spr.zeige__wgruppe.spr_uebvar_id 1345 AND 1346 -- 1347 -- Sprache Auswählen 1348 -- 1349 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1350 ) 1351 -- 1352 -- Zusatzinformationen 1353 -- 1354 LEFT OUTER JOIN spr.zeige__wgruppe AS zus ON ( 1355 prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id_zus = 1356 zus.spr_uebvar_id 1357 AND 1358 -- 1359 -- Sprache Auswählen 1360 -- 1361 zus.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1362 ) 1363 -- 1364 -- Ausgaben 1365 -- 1366 LEFT OUTER JOIN prj.zeige__dokdoku AS ausgabe ON ( 1367 prj.zeige__dokdoku.dok__doku__id = ausgabe.dok__doku__id 1368 AND 1369 -- 1370 -- Die Ausgaben wurden nicht entfernt 1371 -- 1372 ausgabe.prj__pl_dokausgabe__logentfernt = false 1373 1374 AND 1375 -- 1376 -- Projekte müssen übereinstimmen 1377 -- 1378 prj.zeige__dokdoku.prj__pl_prtdokdoku__prj_projekte_id = 1379 ausgabe.prj__pl_prtdokdoku__prj_projekte_id 1380 ) 1381 -- 1382 -- Ausschließlich die letzten (aktuellen) Ausgaben anzeigen 1383 -- 1384 INNER JOIN prj.zeige__pl_dokausgabe_le ON ( 1385 prj.zeige__pl_dokausgabe_le.prj__pl_dokausgabe__id = 1386 ausgabe.prj__pl_dokausgabe__id 1387 ) 1388 WHERE 1389 -- 1390 -- Gefahrenszenarien und Protokolleinträge verbinden 1391 -- 1392 prj.zeige__pl_prtpsgefszenario.id = prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id 1393 AND 1394 prj.zeige__pl_prtpsgefszenario.logentfernt = false 1395 AND 1396 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id = prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id 1397 AND 1398 -- 1399 -- Ausschließlich die letzten (aktuellen) Dokumente anzeigen, ... 1400 -- 1401 prj.zeige__pl_prtdokdoku_le.prj__pl_prtdokdoku__id = 1402 prj.zeige__dokdoku.prj__pl_prtdokdoku__id 1403 AND 1404 -- 1405 -- ... die nicht entfernt wurden 1406 -- 1407 prj.zeige__dokdoku.prj__pl_prtdokdoku__logentfernt = false 1408 AND 1409 -- 1410 -- Nulldokument nicht zeigen 1411 -- 1412 prj.zeige__dokdoku.dok__doku__id > 0""" 1413 + projekt 1414 + protokoll 1415 + gefszenario 1416 + firma 1417 + doku 1418 + """ 1419 1420 UNION 1421 1422 -- 1423 -- Dokumente anzeigen 1424 -- 1425 SELECT DISTINCT 1426 -- 1427 -- Dokumente 1428 -- 1429 prj.zeige__dokdoku.dok__doku__id 1430 , prj.zeige__dokdoku.dok__doku__notizen 1431 , prj.zeige__dokdoku.prj__pl_prtdokdoku__nr 1432 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) 1433 , prj.zeige__dokdoku.prj__pl_prtdokdoku__notizen 1434 -- 1435 -- Ausgaben 1436 -- 1437 , NULL AS stand 1438 , CAST( NULL AS varchar ) AS datum 1439 , NULL AS ausg_notizen 1440 -- 1441 -- Dokumente 1442 -- 1443 , prj.zeige__dokdoku.dok__doku__aspekt AS dok_aspekt 1444 , COALESCE( zus.wgruppe, '??' ) AS zus 1445 , prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id 1446 , prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id_zus 1447 -- 1448 -- Ausgaben 1449 -- 1450 , CAST( NULL AS boolean ) AS istfrei 1451 , prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id 1452 1453 , prj.zeige__dokdoku.dok__doku__spr_uebvar_id_kb 1454 , prj.zeige__dokdoku.dok__doku__intern_firma_id 1455 FROM 1456 prj.zeige__pl_prtpsgefszenario 1457 , prj.zeige__pl_prtpsgefszenario_le 1458 , prj.zeige__pl_prtdokdoku_le 1459 , prj.zeige__dokdoku 1460 -- 1461 -- Dokumententitel 1462 -- 1463 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 1464 prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id = 1465 spr.zeige__wgruppe.spr_uebvar_id 1466 AND 1467 -- 1468 -- Sprache Auswählen 1469 -- 1470 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1471 ) 1472 -- 1473 -- Zusatzinformationen 1474 -- 1475 LEFT OUTER JOIN spr.zeige__wgruppe AS zus ON ( 1476 prj.zeige__dokdoku.prj__pl_prtdokdoku__spr_uebvar_id_zus = 1477 zus.spr_uebvar_id 1478 AND 1479 -- 1480 -- Sprache Auswählen 1481 -- 1482 zus.spr_sprachen_id = """ + str( sprSprachenId ) + """ 1483 ) 1484 WHERE 1485 -- 1486 -- Gefahrenszenarien und Protokolleinträge verbinden 1487 -- 1488 prj.zeige__pl_prtpsgefszenario.id = prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id 1489 AND 1490 prj.zeige__pl_prtpsgefszenario.logentfernt = false 1491 AND 1492 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id = prj.zeige__dokdoku.prj__pl_prtdokdoku__prt_protokoll_id 1493 AND 1494 -- 1495 -- Ausschließlich die letzten (aktuellen) Dokumente anzeigen, ... 1496 -- 1497 prj.zeige__pl_prtdokdoku_le.prj__pl_prtdokdoku__id = 1498 prj.zeige__dokdoku.prj__pl_prtdokdoku__id 1499 AND 1500 -- 1501 -- ... die nicht entfernt wurden 1502 -- 1503 prj.zeige__dokdoku.prj__pl_prtdokdoku__logentfernt = false 1504 AND 1505 -- 1506 -- Nulldokument nicht zeigen 1507 -- 1508 prj.zeige__dokdoku.dok__doku__id > 0 1509 AND 1510 -- 1511 -- Dokumente, denen noch keine Ausgabe zugeordnet ist 1512 -- 1513 prj.zeige__dokdoku.prj__pl_dokausgabe__id IS NULL""" 1514 + projekt 1515 + protokoll 1516 + gefszenario 1517 + firma 1518 + doku 1519 + """;""" )

1520 1521 # # 1522 # # -- SQL-Abfrageergebnis einschränken ---------------------------------- 1523 # # 1524 # firma = "" 1525 # if( internFirmaId is not None ) : 1526 # firma = """ 1527 #AND 1528 # -- 1529 # -- Firma einschränken 1530 # -- 1531 # dok.doku.intern_firma_id = """ + str( internFirmaId ) + """ 1532 # """ 1533 # 1534 # dokument = "" 1535 # 1536 # if( dokDokuId is not None ) : 1537 # dokument = """ 1538 #AND 1539 # -- 1540 # -- Dokument einschränken 1541 # -- 1542 # dok.doku.id = """ + str( dokDokuId ) + """ 1543 # """ 1544 # 1545 # 1546 # # 1547 # # -- SQL-Abfrage ausführen -------------------------------------------------- 1548 # # 1549 # self.__dbAbfrage__( self.__gibSQLSelect__( 1550 # select = """ 1551 #SELECT DISTINCT 1552 # -- 0 1553 # id 1554 # , aspekt 1555 # -- 2 1556 # , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS wgruppe 1557 # , notizen 1558 # -- 4 1559 # , spr_uebvar_id_kb 1560 # , intern_firma_id""" 1561 # , tabellen = [ self.__gibSQLSelect__DokDoku__( sprSprachenId = self.filter__spr_sprachen_id 1562 # , sqlJOIN = "" 1563 # , sqlWHERE = """ 1564 #AND 1565 # dok.doku.id > 0 """ + firma + dokument ) ] 1566 # , sqlWHERE = """ 1567 #ORDER BY 1568 # wgruppe""" ) ) 1569 # 1570 # 1571 1572 1573 1574 1575 # 1576 # ------------------------------------------------------------------------------------ 1577 # ------------------------------------------------------------------------------------ 1578 # -- SQL-Abfrage zur Selektion der Protokolleinträge ------------------ 1579 # ------------------------------------------------------------------------------------ 1580 # ------------------------------------------------------------------------------------ 1581 #

1582 - def __gibSQL_prjPrtProtokoll__( self, prtProtokollId = None, sqlProjekteIdIN = True ):

1583 """ 1584 Methode, die die SQL-Abfrage zurückgibt, die Detailinformationen zu Protokolleinträgen, Sicherheitsanforderungen oder Terminplaneinträgen aus der Datenbank liest. 1585 1586 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 1587 @type prtProtokollId: Ganzzahl(liste) 1588 1589 @param sqlProjekteIdIN: Es ist C{True} anzugeben, wenn C{prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id IN(self.filter__prj_projekte_id)} engegeben werden soll. Bei C{False} wird C{prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id NOT IN(self.filter__prj_projekte_id)} verwendet. 1590 @type sqlProjekteIdIN: Ganzzahl 1591 1592 @return: Es wird die SQL-Abfrage zurückgegeben. 1593 @rtype: Zeichenette 1594 """ 1595 1596 # 1597 # -- NOT zusammenstellen -------------------------------------------------- 1598 # 1599 NOT = "" 1600 if( not sqlProjekteIdIN ) : NOT = "NOT" 1601 1602 1603 # 1604 # -- Auf Protokolleinträge einschränken ---------------------------------- 1605 # 1606 sqlPrtProtokollId = '' 1607 if( prtProtokollId is not None ): 1608 1609 sqlPrtProtokollId = ( """ 1610 AND 1611 -- 1612 -- Protokolleintrag auswählen 1613 -- 1614 prj.zeige__prtprotokoll.prt__protokoll__id IN( """ + str( prtProtokollId ) + """ )""" ) 1615 1616 1617 # 1618 # -- SQL-Abfrage zurückgeben ------------------------------------------ 1619 # 1620 return( """ 1621 -- 1622 -- Details zu den Protokolleinträgen 1623 -- 1624 SELECT DISTINCT 1625 -- 0 1626 prj.zeige__prtprotokoll.prt__typ__id 1627 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen 1628 -- 2 1629 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS proteintrag 1630 , to_char( prj.zeige__prtprotokoll.prj__pp_prtprotokoll__datuhrz, 'DD.MM.YYYY' ) 1631 -- 4 1632 , to_char( prj.zeige__prtprotokoll.prj__pp_prtprotokoll__duanfrage, 'DD.MM.YYYY' ) 1633 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__erledigt 1634 -- 6 1635 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__intern 1636 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_personen_id 1637 -- 8 1638 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__teilnehmer 1639 , to_char( prj.zeige__prtprotokoll.prj__pp_prtprotokoll__termin, 'DD.MM.YYYY' ) 1640 -- 10 1641 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__id 1642 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id 1643 -- 12 1644 , prj.zeige__prtprotokoll.prt__protokoll__id 1645 FROM 1646 prj.zeige__prtprotokoll 1647 -- 1648 -- Text der Protokolleinträge darstellen 1649 -- 1650 LEFT OUTER JOIN spr.zeige__wgruppe 1651 ON ( 1652 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id = 1653 spr.zeige__wgruppe.spr_uebvar_id 1654 AND 1655 -- 1656 -- Sprache Auswählen 1657 -- 1658 spr.zeige__wgruppe.spr_sprachen_id = """ 1659 + str( self.filter__spr_sprachen_id ) + """ 1660 ) 1661 WHERE 1662 -- 1663 -- Projekt auswählen 1664 -- 1665 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id """ + NOT + """ IN( """ + str( self.filter__prj_projekte_id ) + """ )""" 1666 + sqlPrtProtokollId + """ 1667 ;""" )

1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 # 1680 # ------------------------------------------------------------------------------------ 1681 # ------------------------------------------------------------------------------------ 1682 # -- SQL-Abfrage zur Selektion der Protokolleinträge unter ------------------ 1683 # -- Berücksichtigung des Gefahrenszenarios ------------------ 1684 # ------------------------------------------------------------------------------------ 1685 # ------------------------------------------------------------------------------------ 1686 #

1687 - def __gibSQL_psPrtProtokoll__( self, prtTypAspekt, prtTypId = None, sqlINpsGefszenId = True, prtProtokollIdVorg = None, prtProtokollIdNachf = None, ignorierePrjProjekteId = False, ignoriereSprSprachenId = False, ignorierePsGefszenarioId = False ):

1688 """ 1689 Methode, die die SQL-Abfrage zurückgibt, die Detailinformationen zu Protokolleinträgen, Sicherheitsanforderungen oder Terminplaneinträgen aus der Datenbank liest. 1690 1691 @param prtTypAspekt: Es ist der Aspekt des Protokolleintrages (C{prt.typ.aspekt}) zu übergeben. 1692 @type prtTypAspekt: Zeichenkette 1693 1694 @param prtTypId: Es ist die Datenbankidentifikationsnummer (C{prt.typ.id}) des Typs des aktuellen Protokolleintrages zu übergeben. 1695 @type prtTypId: Ganzzahl 1696 1697 @param sqlINpsGefszenId: Wenn C{True} angegeben wird, werden die Protokolleinträge zum Gefahrenszenario ausgewählt. Sonst nicht. 1698 @type sqlINpsGefszenId: Boolean 1699 1700 @param prtProtokollIdVorg: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 1701 @type prtProtokollIdVorg: Ganzzahl(liste) 1702 1703 @param prtProtokollIdNachf: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 1704 @type prtProtokollIdNachf: Ganzzahl(liste) 1705 1706 @param ignorierePrjProjekteId: Es ist die C{True} anzugeben, wenn C{self.filter__prj_projekte_id} in der SQL-Abfrage berücksichtigt werden soll. 1707 @type ignorierePrjProjekteId: Boolean 1708 1709 @param ignoriereSprSprachenId: Es ist die C{True} anzugeben, wenn C{self.filter__spr_sprachen_id} in der SQL-Abfrage berücksichtigt werden soll. 1710 @type ignoriereSprSprachenId: Boolean 1711 1712 @param ignorierePsGefszenarioId: Es ist die C{True} anzugeben, wenn C{self.ps_gefszenario_id} in der SQL-Abfrage berücksichtigt werden soll. 1713 @type ignorierePsGefszenarioId: Boolean 1714 1715 @return: Es wird die SQL-Abfrage zurückgegeben. 1716 @rtype: Zeichenette 1717 """ 1718 1719 # 1720 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 1721 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 1722 # 1723 if( self.ps_gefszenario_id is None 1724 and not ignorierePsGefszenarioId ) : 1725 1726 return None 1727 1728 1729 # 1730 # -- Gefahrenszenario-Id ignorieren ---------------------------------- 1731 # 1732 psGefszenarioId = self.ps_gefszenario_id 1733 if( ignorierePsGefszenarioId ) : psGefszenarioId = None 1734 1735 1736 1737 # 1738 # -- Projekt oder Sprache ignorieren ---------------------------------- 1739 # 1740 prjProjekteId = self.filter__prj_projekte_id 1741 if( ignorierePrjProjekteId ) : prjProjekteId = None 1742 1743 sprSprachenId = self.filter__spr_sprachen_id 1744 if( ignoriereSprSprachenId ) : sprSprachenId = None 1745 1746 1747 # 1748 # -- Projekt einschränken -------------------------------------------------- 1749 # 1750 sqlAND = '' 1751 1752 if( prjProjekteId is not None ) : 1753 1754 sqlAND += ( """ 1755 AND 1756 -- 1757 -- Projekt auswählen 1758 -- 1759 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ 1760 + str( prjProjekteId ) ) 1761 1762 1763 # 1764 # -- Gefahrenszenario einschränken ------------------------------------------ 1765 # 1766 sqlNOT = '' 1767 if( not sqlINpsGefszenId ) : sqlNOT = 'NOT ' 1768 1769 if( psGefszenarioId is not None ) : 1770 1771 sqlAND += ( """ 1772 AND 1773 -- 1774 -- Gefahrenszenario auswählen 1775 -- 1776 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id """ + sqlNOT + """IN( """ 1777 + str( psGefszenarioId ) + """ ) """ ) 1778 1779 1780 # 1781 # -- Typ des Protokolleintrages einschränken ---------------------------------- 1782 # 1783 if( prtTypId is not None ) : 1784 1785 sqlAND += ( """ 1786 AND 1787 -- 1788 -- Typ auswählen 1789 -- 1790 prj.zeige__prtprotokoll.prt__typ__id IN( """ + str( prtTypId ) + " )" ) 1791 1792 1793 1794 # 1795 # -- Vorgänger / Nachfolger einschränken ---------------------------------- 1796 # 1797 if( prtProtokollIdVorg is not None ) : 1798 1799 sqlAND += ( """ 1800 AND 1801 -- 1802 -- Vorgänger auswählen 1803 -- 1804 prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prt_protokoll_id_vorg IN( """ 1805 + str( prtProtokollIdVorg ) + " )" ) 1806 1807 if( prtProtokollIdNachf is not None ) : 1808 1809 sqlAND += ( """ 1810 AND 1811 -- 1812 -- Vorgänger auswählen 1813 -- 1814 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id IN( """ 1815 + str( prtProtokollIdNachf ) + " )" ) 1816 1817 1818 # 1819 # -- SQL-Abfrage zurückgeben ------------------------------------------ 1820 # 1821 return( """ 1822 -- 1823 -- Protokolleinträge - es wird der jeweils letzte zugeordnete Eintrag angezeigt 1824 -- (Logbuchfunktion) 1825 -- 1826 SELECT DISTINCT 1827 -- 0 1828 prj.zeige__pl_prtpsgefszenario.id AS gefprot_id 1829 , prj.zeige__prtprotokoll.prt__typ__id AS typ_id 1830 -- 2 1831 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS proteintrag 1832 , prj.zeige__pl_prtpsgefszenario.prt_protokoll_id AS protokoll_id 1833 -- 4 1834 , CASE WHEN( vorgaenger.prt__typ__aspekt = prj.zeige__prtprotokoll.prt__typ__aspekt ) 1835 THEN prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prt_protokoll_id_vorg 1836 END AS protokoll_id_vorg 1837 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id 1838 -- 6 1839 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen 1840 , prj.zeige__prtprotokoll.prj__pp_prtprotokoll__id 1841 -- 1842 -- Kontrolle 1843 -- 1844 --, prj.zeige__pl_prtpsgefszenario.logdatuhrz AS datuhrz 1845 --, prj.zeige__prtprotokoll.prt__typ__aspekt AS aspekt 1846 FROM 1847 prj.zeige__pl_prtpsgefszenario_le 1848 , prj.zeige__pl_prtpsgefszenario 1849 , ( prj.zeige__prtprotokoll 1850 -- 1851 -- Text der Protokolleinträge darstellen 1852 -- 1853 LEFT OUTER JOIN spr.zeige__wgruppe 1854 ON ( 1855 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id = 1856 spr.zeige__wgruppe.spr_uebvar_id 1857 AND 1858 -- 1859 -- Sprache Auswählen 1860 -- 1861 spr.zeige__wgruppe.spr_sprachen_id = """ 1862 + str( sprSprachenId ) + """ 1863 ) 1864 -- 1865 -- Vorgänger zum Protokolleintrag anzeigen 1866 -- 1867 LEFT OUTER JOIN prj.zeige__prtprotokolltabellen 1868 ON ( 1869 prj.zeige__prtprotokolltabellen.prt__protokoll__id = 1870 prj.zeige__prtprotokoll.prt__protokoll__id 1871 AND 1872 prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prj_projekte_id = 1873 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id 1874 ) ) 1875 -- 1876 -- Vorgänger-Id ausblenden, wenn >prt__typ__aspekt< nicht übereinstimmen 1877 -- 1878 LEFT OUTER JOIN prj.zeige__prtprotokoll AS vorgaenger ON ( 1879 vorgaenger.prt__protokoll__id = 1880 prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prt_protokoll_id_vorg 1881 AND 1882 vorgaenger.prj__pp_prtprotokoll__prj_projekte_id = 1883 prj.zeige__prtprotokolltabellen.prj__p_prtverbindung__prj_projekte_id 1884 ) 1885 WHERE 1886 -- 1887 -- Protokolleinträge auf letzte Einträge beschränken 1888 -- 1889 prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id = 1890 prj.zeige__pl_prtpsgefszenario.id 1891 AND 1892 -- 1893 -- die Detailinformationen (Gefahrenszenario, Projekt, Aspekt) zu den 1894 -- Protokolleinträgen holen 1895 -- 1896 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_personen_id = 0 1897 AND 1898 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id = 1899 prj.zeige__prtprotokoll.prt__protokoll__id 1900 AND 1901 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = 1902 prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id 1903 AND 1904 -- 1905 -- die nichtgelöschten Einträge zeigen 1906 -- 1907 prj.zeige__pl_prtpsgefszenario.logentfernt = false 1908 AND 1909 -- 1910 -- Aspekt auswählen 1911 -- 1912 prj.zeige__prtprotokoll.prt__typ__aspekt = '""" + str( prtTypAspekt ) + "'" 1913 1914 + sqlAND + """ 1915 ;""" )

1916 1917 1918 1919 1920 1921 # 1922 # ------------------------------------------------------------------------------------ 1923 # ------------------------------------------------------------------------------------ 1924 # -- -------------------------------------------------- 1925 # -- generische SQL-Abfrage -------------------------------------------------- 1926 # -- -------------------------------------------------- 1927 # ------------------------------------------------------------------------------------ 1928 # ------------------------------------------------------------------------------------ 1929 #

1930 - def __gibSQLSelect__( self, select, tabellen, sqlWHERE = None ):

1931 """ 1932 Methode, die die SQL-Abfrage zurückgibt, die ... 1933 1934 @param select: Es sind die Datenbankspalten anzugeben, die in der SQL-Select-Anweisung verwendet werden. 1935 @type select: Zeichenkette 1936 1937 @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. 1938 @type tabellen: Python-Liste 1939 1940 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 1941 @type sqlWHERE: Zeichenkette 1942 1943 @return: Es wird die SQL-Abfrage zurückgegeben. 1944 @rtype: Zeichenette 1945 """ 1946 1947 # 1948 # -- tabellen[i][0] Tabellenname(n) - es können mehrere Tabellennamen -- 1949 # -- übergeben werden (z.B. bei Logbuchtabellen) -- 1950 # -- -- 1951 # -- tabellen[i][1] Es ist die Spalte der Projekt-Identifikationsnummern -- 1952 # -- der Tabelle anzugeben (schema.tabelle.prj_projekte_id) -- 1953 # -- (darf None sein) -- 1954 # -- -- 1955 # -- tabellen[i][2] Wenn mehrere Tabellennamen übergeben werden, ist hier -- 1956 # -- die Verbindung zwischen den Tabellen anzugeben -- 1957 # -- (darf None sein) -- 1958 # -- -- 1959 # -- tabellen[i][3] Es ist eine beliebige zusätzliche JOIN-Anweisung -- 1960 # -- anzugeben -- 1961 # -- (darf None sein) -- 1962 # -- -- 1963 # -- tabellen[i][4] Es ist eine beliebige zusätzliche WHERE-Anweisung -- 1964 # -- anzugeben -- 1965 # -- (darf None sein) -- 1966 # -- 1967 1968 # 1969 # -- FROM und WHERE zusammenstellen, die aus den Tabellen gebildet werden -- 1970 # 1971 sqlFROM = '' 1972 sqlWhereIntern = '' 1973 1974 for i in range( len( tabellen ) ) : 1975 1976 # 1977 # -- Tabellennamen ausgeben ------------------------------------------ 1978 # 1979 if( i > 0 or sqlWHERE is not None ) : 1980 1981 sqlWhereIntern = sqlWhereIntern + ( """ 1982 -- 1983 -- 1984 -- -- """ + tabellen[i][0] + """ --------------------------------- 1985 -- 1986 --""" ) 1987 1988 1989 # 1990 # -- Liste ---------------------------------------------------------- 1991 # 1992 sqlFROM = sqlFROM + '\n\t' 1993 if( i > 0 ) : 1994 sqlFROM = sqlFROM + ', ' 1995 sqlWhereIntern = sqlWhereIntern + '\nAND\n' 1996 1997 # 1998 # -- FROM ---------------------------------- 1999 # -- - Tabellenname übernehmen ---------------------------------- 2000 # -- - JOIN-Anweisung übernehmen ---------------------------------- 2001 # 2002 sqlFROM = sqlFROM + tabellen[i][0] 2003 2004 if( tabellen[i][3] is not None ) : 2005 sqlFROM = sqlFROM + tabellen[i][3] 2006 2007 # 2008 # -- WHERE -------------------------- 2009 # -- - Projekt-Id mit Tabelle 1 verbinden -------------------------- 2010 # -- - mehrere Tabellen verbinden -------------------------- 2011 # -- - WHERE-Anweisung übernehmen -------------------------- 2012 # 2013 if( i > 0 2014 and tabellen[0][1] is not None 2015 and tabellen[i][1] is not None ) : 2016 sqlWhereIntern = "\t" + sqlWhereIntern + "\t" + tabellen[0][1] + " =\n\t\t" + tabellen[i][1] 2017 2018 2019 if( tabellen[i][2] is not None ) : 2020 2021 sqlWhereIntern = sqlWhereIntern + "\n" 2022 if( i > 0 ) : sqlWhereIntern = sqlWhereIntern + "AND\n" 2023 sqlWhereIntern = sqlWhereIntern + "\t" + tabellen[i][2] 2024 2025 if( tabellen[i][4] is not None ) : 2026 sqlWhereIntern = sqlWhereIntern + tabellen[i][4] 2027 2028 2029 # 2030 # -- sqlWHERE ---------------------------------------------------------- 2031 # 2032 if( sqlWHERE is not None ) : sqlWhereIntern = sqlWhereIntern + sqlWHERE 2033 2034 2035 # 2036 # -- SQL-Abfrage zurückgeben ------------------------------------------ 2037 # 2038 if( len( sqlWhereIntern ) > 0 ) : sqlWhereIntern = "\nWHERE" + sqlWhereIntern 2039 2040 return( select 2041 + "\nFROM" + sqlFROM 2042 + sqlWhereIntern 2043 + ";" )

2044 2045 2046 2047 2048 2049 2050 # 2051 # ------------------------------------------------------------------------------------ 2052 # ------------------------------------------------------------------------------------ 2053 # -- -------------------------- 2054 # -- Hilfsfunktion zur generischen SQL-Abfrage -------------------------- 2055 # -- -------------------------- 2056 # ------------------------------------------------------------------------------------ 2057 # ------------------------------------------------------------------------------------ 2058 #

2059 - def __gibSQLSelect_H__( self, tabellenNamen, prjProjekteId = None, tabellenVerbindung = None, sqlJOIN = None, sqlWHERE = None ):

2060 """ 2061 Hilfsfunktion zur generischen SQL-Abfrage, die die benötigten Detailinformationen zurückgibt. 2062 2063 @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. 2064 @type tabellen: Python-Liste 2065 2066 2067 @param tabellenNamen: Tabellenname(n) - es können mehrere Tabellennamen übergeben werden (z.B. bei Logbuchtabellen) 2068 @type tabellenNamen: Zeichenkette 2069 2070 @param prjProjekteId: Es ist die Spalte der Projekt-Identifikationsnummern der Tabelle anzugeben C{schema.tabelle.prj_projekte_id (darf None sein)} 2071 @type prjProjekteId: Zeichenkette 2072 2073 @param tabellenVerbindung: Wenn mehrere Tabellennamen übergeben werden, ist hier die Verbindung zwischen den Tabellen anzugeben C{(darf None sein)} 2074 @type tabellenVerbindung: Zeichenkette 2075 2076 @param sqlJOIN: Es kann eine beliebige zusätzliche JOIN-Anweisung anzugeben C{(darf None sein)} 2077 @type sqlJOIN: Zeichenkette 2078 2079 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 2080 @type sqlWHERE: Zeichenkette 2081 2082 @return: Es wird die SQL-Abfrage zurückgegeben. 2083 @rtype: Zeichenette 2084 """ 2085 2086 # 2087 # -- tabellen[i][0] Tabellenname(n) - es können mehrere Tabellennamen -- 2088 # -- übergeben werden (z.B. bei Logbuchtabellen) -- 2089 # -- -- 2090 # -- tabellen[i][1] Es ist die Spalte der Projekt-Identifikationsnummern -- 2091 # -- der Tabelle anzugeben (schema.tabelle.prj_projekte_id) -- 2092 # -- -- 2093 # -- tabellen[i][2] Wenn mehrere Tabellennamen übergeben werden, ist hier -- 2094 # -- die Verbindung zwischen den Tabellen anzugeben -- 2095 # -- (darf None sein) -- 2096 # -- -- 2097 # -- tabellen[i][3] Es ist eine beliebige zusätzliche JOIN-Anweisung -- 2098 # -- anzugeben -- 2099 # -- (darf None sein) -- 2100 # -- -- 2101 # -- tabellen[i][4] Es ist eine beliebige zusätzliche WHERE-Anweisung -- 2102 # -- anzugeben -- 2103 # -- (darf None sein) -- 2104 # -- 2105 return[tabellenNamen, prjProjekteId, tabellenVerbindung, sqlJOIN, sqlWHERE]

2106 2107 2108 2109 2110 # 2111 # ------------------------------------------------------------------------------------ 2112 # ------------------------------------------------------------------------------------ 2113 # -- -------------------------- 2114 # -- Liste der Tabellenwerte für >__gibSQLSelect__()< -------------------------- 2115 # -- -------------------------- 2116 # -- -> dok.doku -------------------------- 2117 # -- -------------------------- 2118 # ------------------------------------------------------------------------------------ 2119 # ------------------------------------------------------------------------------------ 2120 #

2121 - def __gibSQLSelect__DokDoku__( self, sprSprachenId, sqlJOIN = "", sqlWHERE = None ):

2122 """ 2123 Methode, die die Liste der Tabellenwerte für C{dok.doku} zurückgibt, die in C{__gibSQLSelect__(... , tabellen )} verwendet werden kann. 2124 2125 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben. 2126 @type sprSprachenId: Ganzzahl 2127 2128 @param sqlJOIN: Es kann eine JOIN-Anweisung angegeben werden. Darf auch C{None} sein. 2129 @type sqlJOIN: Zeichenkette 2130 2131 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 2132 @type sqlWHERE: Zeichenkette 2133 2134 @return: Es wird die Python-Liste für C{__gibSQLSelect__(... , tebellen )} zurückgegeben. 2135 @rtype: Python-Liste 2136 """ 2137 2138 # 2139 # -- Liste zurückgeben -------------------------------------------------- 2140 # 2141 return self.__gibSQLSelect_H__( tabellenNamen = "dok.doku" 2142 , prjProjekteId = None 2143 , tabellenVerbindung = None 2144 , sqlJOIN = """ LEFT OUTER JOIN spr.zeige__wgruppe 2145 ON ( 2146 -- 2147 -- Wortgruppe zuordnen 2148 -- 2149 dok.doku.spr_uebvar_id_kb = spr.zeige__wgruppe.spr_uebvar_id 2150 AND 2151 -- 2152 -- Sprache Auswählen 2153 -- 2154 spr.zeige__wgruppe.spr_sprachen_id = """ + str( sprSprachenId ) + """ ) """ 2155 + sqlJOIN 2156 , sqlWHERE = """ 2157 dok.doku.idfrei = 0""" 2158 + sqlWHERE )

2159 2160 2161 2162 2163 # 2164 # ------------------------------------------------------------------------------------ 2165 # ------------------------------------------------------------------------------------ 2166 # -- -------------------------- 2167 # -- Liste der Tabellenwerte für >__gibSQLSelect__()< -------------------------- 2168 # -- -------------------------- 2169 # -- -> prj.zeige__pl_prtpsgefszenario_le -------------------------- 2170 # -- -> prj.zeige__pl_prtpsgefszenario -------------------------- 2171 # -- -------------------------- 2172 # ------------------------------------------------------------------------------------ 2173 # ------------------------------------------------------------------------------------ 2174 #

2175 - def __gibSQLSelect__PlPrtPsGefszenario__( self, sqlJOIN = None, sqlWHERE = None ):

2176 """ 2177 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. 2178 2179 @param sqlJOIN: Es kann eine JOIN-Anweisung angegeben werden. Darf auch C{None} sein. 2180 @type sqlJOIN: Zeichenkette 2181 2182 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 2183 @type sqlWHERE: Zeichenkette 2184 2185 @return: Es wird die Python-Liste für C{__gibSQLSelect__(... , tebellen )} zurückgegeben. 2186 @rtype: Python-Liste 2187 """ 2188 2189 # 2190 # -- Der (die) Tabellenname(n) werden immer zurückgegeben ------------------ 2191 # 2192 liste = [] 2193 liste.append( "prj.zeige__pl_prtpsgefszenario_le, prj.zeige__pl_prtpsgefszenario" ) 2194 2195 2196 # 2197 # -- Der Spaltenname der Projekt-Identifikationsnummer wird immer ---------- 2198 # -- zurückgegeben ---------- 2199 # 2200 liste.append( "prj.zeige__pl_prtpsgefszenario.prj_projekte_id" ) 2201 2202 2203 # 2204 # -- Die Vebindung zwischen beiden Tabellen zurückgegeben ------------------ 2205 # 2206 liste.append( """prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id = 2207 prj.zeige__pl_prtpsgefszenario.id 2208 AND 2209 prj.zeige__pl_prtpsgefszenario.logentfernt = false""" ) 2210 2211 2212 # 2213 # -- JOIN-Anweisung übernehmen ------------------------------------------ 2214 # 2215 liste.append( sqlJOIN ) 2216 2217 2218 # 2219 # -- WHERE-Anweisung übernehmen ------------------------------------------ 2220 # 2221 liste.append( sqlWHERE ) 2222 2223 2224 # 2225 # -- Liste zurückgeben -------------------------------------------------- 2226 # 2227 return liste

2228 2229 2230 2231 # 2232 # ------------------------------------------------------------------------------------ 2233 # ------------------------------------------------------------------------------------ 2234 # -- -------------------------- 2235 # -- Liste der Tabellenwerte für >__gibSQLSelect__()< -------------------------- 2236 # -- -------------------------- 2237 # -- -> prj.zeige__prtprotokolltabellen -------------------------- 2238 # -- prt__protokoll__id -------------------------- 2239 # -- prj__p_prtstrstrkt__id -------------------------- 2240 # -- prj__p_prtstrstrkt__notizen -------------------------- 2241 # -- prj__p_prtstrstrkt__prj_projekte_id -------------------------- 2242 # -- prj__p_prtstrstrkt__str_strkt_id -------------------------- 2243 # -- -------------------------- 2244 # ------------------------------------------------------------------------------------ 2245 # ------------------------------------------------------------------------------------ 2246 #

2247 - def __gibSQLSelect__PrtProtokolltabellenStrStrkt__( self, sqlJOIN = None, sqlWHERE = None ):

2248 """ 2249 Methode, die die Liste der Tabellenwerte für C{prj.zeige__prtprotokolltabellen -> Strukturpunkte} zurückgibt, die in C{__gibSQLSelect__(... , tabellen )} verwendet werden kann. 2250 2251 @param sqlJOIN: Es kann eine JOIN-Anweisung angegeben werden. Darf auch C{None} sein. 2252 @type sqlJOIN: Zeichenkette 2253 2254 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 2255 @type sqlWHERE: Zeichenkette 2256 2257 @return: Es wird die Python-Liste für C{__gibSQLSelect__(... , tebellen )} zurückgegeben. 2258 @rtype: Python-Liste 2259 """ 2260 2261 # 2262 # -- Der (die) Tabellenname(n) werden immer zurückgegeben ------------------ 2263 # 2264 liste = [] 2265 liste.append( "prj.zeige__prtprotokolltabellen" ) 2266 2267 2268 # 2269 # -- Der Spaltenname der Projekt-Identifikationsnummer wird immer ---------- 2270 # -- zurückgegeben ---------- 2271 # 2272 liste.append( "prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__prj_projekte_id" ) 2273 2274 2275 # 2276 # -- Die Vebindung zwischen beiden Tabellen zurückgegeben ------------------ 2277 # 2278 liste.append( None ) 2279 2280 2281 # 2282 # -- JOIN-Anweisung übernehmen ------------------------------------------ 2283 # 2284 liste.append( sqlJOIN ) 2285 2286 2287 # 2288 # -- WHERE-Anweisung übernehmen ------------------------------------------ 2289 # 2290 liste.append( sqlWHERE ) 2291 2292 2293 # 2294 # -- Liste zurückgeben -------------------------------------------------- 2295 # 2296 return liste

2297 2298 2299 2300 # 2301 # ------------------------------------------------------------------------------------ 2302 # ------------------------------------------------------------------------------------ 2303 # -- -------------------------- 2304 # -- Liste der Tabellenwerte für >__gibSQLSelect__()< -------------------------- 2305 # -- -------------------------- 2306 # -- -> prj.zeige__strstrkt -------------------------- 2307 # -- -------------------------- 2308 # ------------------------------------------------------------------------------------ 2309 # ------------------------------------------------------------------------------------ 2310 #

2311 - def __gibSQLSelect__StrStrkt__( self, sqlJOIN = None, sqlWHERE = None ):

2312 """ 2313 Methode, die die Liste der Tabellenwerte für C{prj.zeige__strstrkt} zurückgibt, die in C{__gibSQLSelect__(... , tabellen )} verwendet werden kann. 2314 2315 @param sqlJOIN: Es kann eine JOIN-Anweisung angegeben werden. Darf auch C{None} sein. 2316 @type sqlJOIN: Zeichenkette 2317 2318 @param sqlWHERE: Es kann eine WHERE-Anweisung angegeben werden. Darf auch C{None} sein. 2319 @type sqlWHERE: Zeichenkette 2320 2321 @return: Es wird die Python-Liste für C{__gibSQLSelect__(... , tebellen )} zurückgegeben. 2322 @rtype: Python-Liste 2323 """ 2324 2325 # 2326 # -- Der (die) Tabellenname(n) werden immer zurückgegeben ------------------ 2327 # 2328 liste = [] 2329 liste.append( "prj.zeige__strstrkt" ) 2330 2331 2332 # 2333 # -- Der Spaltenname der Projekt-Identifikationsnummer wird immer ---------- 2334 # -- zurückgegeben ---------- 2335 # 2336 liste.append( "prj.zeige__strstrkt.prj_projekte_id" ) 2337 2338 2339 # 2340 # -- Die Vebindung zwischen beiden Tabellen zurückgegeben ------------------ 2341 # 2342 liste.append( None ) 2343 2344 2345 # 2346 # -- JOIN-Anweisung übernehmen ------------------------------------------ 2347 # 2348 liste.append( sqlJOIN ) 2349 2350 2351 # 2352 # -- WHERE-Anweisung übernehmen ------------------------------------------ 2353 # 2354 liste.append( sqlWHERE ) 2355 2356 2357 # 2358 # -- Liste zurückgeben -------------------------------------------------- 2359 # 2360 return liste

2361 2362 2363 2364 # 2365 # ------------------------------------------------------------------------------------ 2366 # ------------------------------------------------------------------------------------ 2367 # -- Die permanenten Datenstrukturen aktualisieren -------------------------- 2368 # ------------------------------------------------------------------------------------ 2369 # ------------------------------------------------------------------------------------ 2370 #

2371 - def aktualisierePermanenteDatenstrukturen( self, wxProgressDialog, istFilter = True ) :

2372 """Es wird die Datenbank ausgelesen und die permanenten Datenstrukturen aktualisiert. 2373 2374 @note: Das übergebene Meldungsfenster (C{wxProgressDialog}) wird verändert ! 2375 2376 @param wxComboBox: Es ist das Meldungsfenster zu übergeben, welches den Fortschritt der Datenbankabfragen anzeigt. 2377 @type wxComboBox: wxPython - ProgressDialog 2378 2379 @param istFilter: Es ist C{True} anzugeben, die Routine nach Aufruf des Dialoges C{Filter} aufgerufen wird. 2380 @type istFilter: Boolean 2381 """ 2382 2383 # 2384 # -- Fortschrittsanzeige initialisieren ---------------------------------- 2385 # -- 2386 # -- beim Programmstart werden 10 SQL-Abfrage ausgeführt ------------------ 2387 # -- beim Filter werden 15 SQL-Abfrage ausgeführt ------------------ 2388 # 2389 wxProgressDialog.SetMinSize( ( 400, 100 ) ) 2390 wxProgressDialog.CenterOnScreen() 2391 2392 fortschritt = 0 2393 beschr = "Aktuelle Abfrage:\n" 2394 2395 delta = 100 / 10 2396 if( istFilter ) : delta = 100 / 15 2397 2398 2399 2400 # 2401 # -- Permanente Datenstrukturen initialisieren, die vom ---------- 2402 # -- Formular 'Filter' benötigt werden ---------- 2403 # -- ---------- 2404 # -- gleichzeitig verhindern, daß Datenbankabfragen in anderen ---------- 2405 # -- Konstruktoren ausgeführt werden ---------- 2406 # -- ---------- 2407 # -- (Nur bei Programmstart) ------------------------------------------ 2408 # 2409 self.daten__prtTyp__Sprache = [] 2410 self.init__prtTyp__Sprache() 2411 fortschritt += delta 2412 wxProgressDialog.Update( value = fortschritt 2413 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2414 2415 self.daten__psAbk__Projekt__Sprache.clear() 2416 self.init__psAbk__Projekt__Sprache( ComboBoxErg_ListBoxSpWTitelAL = None, psAbkTyp = None ) 2417 fortschritt += delta 2418 wxProgressDialog.Update( value = fortschritt 2419 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2420 2421 self.daten__dokDoku__Projekt__Sprache = [] 2422 self.init__dokDoku__Projekt__Sprache() 2423 fortschritt += delta 2424 wxProgressDialog.Update( value = fortschritt 2425 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2426 2427 self.daten__prtProtokoll_gefProt__Projekt__Sprache.clear() 2428 self.daten__prtProtokoll_gefProt_vorg__Projekt__Sprache.clear() 2429 self.daten__prtProtokoll_siAnf__Projekt__Sprache.clear() 2430 self.daten__prtProtokoll_siAnf_vorg__Projekt__Sprache.clear() 2431 self.daten__prtProtokoll_siAnf_gefProt__Projekt__Sprache.clear() 2432 self.init__prtProtokoll__Projekt__Sprache() 2433 fortschritt += delta 2434 wxProgressDialog.Update( value = fortschritt 2435 , newmsg = beschr.replace( '\n', '\ninit__prtProtokoll__Projekt__Sprache()' ) ) 2436 2437 self.daten__strStrkt__Projekt__Sprache = [] 2438 self.init__strStrkt__Projekt__Sprache() 2439 fortschritt += delta 2440 wxProgressDialog.Update( value = fortschritt 2441 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2442 2443 if( not istFilter ) : 2444 2445 self.init__strName() 2446 fortschritt += delta 2447 wxProgressDialog.Update( value = fortschritt 2448 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2449 2450 self.init__internFirma() 2451 fortschritt += delta 2452 wxProgressDialog.Update( value = fortschritt 2453 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2454 2455 self.init__prjPersonen( wxListBox = None ) 2456 fortschritt += delta 2457 wxProgressDialog.Update( value = fortschritt 2458 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2459 2460 self.init__prjProjekte( wxComboBox = None ) 2461 fortschritt += delta 2462 wxProgressDialog.Update( value = fortschritt 2463 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2464 2465 self.init__sprSprachen( wxComboBox = None ) 2466 fortschritt += delta 2467 wxProgressDialog.Update( value = fortschritt 2468 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2469 2470 wxProgressDialog.Destroy() 2471 2472 return 2473 2474 2475 2476 # 2477 # -- Permanente Datenstrukturen aktualisieren, nachdem 'Filter' ---------- 2478 # -- aufgerufen wurde ---------- 2479 # 2480 self.daten__ProtId_DokuId__Projekt.clear() 2481 self.init__ProtId_DokuId__Projekt() 2482 fortschritt += delta 2483 wxProgressDialog.Update( value = fortschritt 2484 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2485 2486 self.daten__ProtId_PersId_aufgabe__Projekt.clear() 2487 self.daten__ProtId_PersId_teilnehmer__Projekt.clear() 2488 self.init__ProtId_PersId__Projekt() 2489 fortschritt += delta 2490 wxProgressDialog.Update( value = fortschritt 2491 , newmsg = beschr.replace( '\n', '\ninit__ProtId_PersId__Projekt()' ) ) 2492 2493 self.daten__ProtId_DatUhrz_aufgabe__Projekt.clear() 2494 self.daten__ProtId_DatUhrz_teilnehmer__Projekt.clear() 2495 self.init__ProtId_DatUhrz__Projekt() 2496 fortschritt += delta 2497 wxProgressDialog.Update( value = fortschritt 2498 , newmsg = beschr.replace( '\n', '\ninit__ProtId_DatUhrz__Projekt()' ) ) 2499 2500 self.daten__psAbk_Risikomatrix.clear() 2501 self.init__psAbk_Risikomatrix() 2502 fortschritt += delta 2503 wxProgressDialog.Update( value = fortschritt 2504 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2505 2506 self.daten__GefszenId_AbkId_gp__Projekt__Sprache.clear() 2507 self.daten__GefszenId_AbkId_rh__Projekt__Sprache.clear() 2508 self.daten__GefszenId_AbkId_rg__Projekt__Sprache.clear() 2509 self.daten__GefszenId_AbkId_rr__Projekt__Sprache.clear() 2510 self.init__GefszenId_AbkId__Projekt__Sprache() 2511 fortschritt += delta 2512 wxProgressDialog.Update( value = fortschritt 2513 , newmsg = beschr.replace( '\n', '\ninit__GefszenId_AbkId__Projekt__Sprache()' ) ) 2514 2515 self.daten__GefszenId_AnmId__Projekt__Sprache.clear() 2516 self.init__GefszenId_AnmId__Projekt__Sprache() 2517 fortschritt += delta 2518 wxProgressDialog.Update( value = fortschritt 2519 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2520 2521 self.daten__GefszenId_Wortgruppen__Projekt__Sprache.clear() 2522 self.init__GefszenId_Wortgruppen__Projekt__Sprache() 2523 fortschritt += delta 2524 wxProgressDialog.Update( value = fortschritt 2525 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2526 2527 self.daten__GefszenId_ProtId_gefProt__Projekt.clear() 2528 self.daten__GefszenId_ProtId_siAnf__Projekt.clear() 2529 self.init__GefszenId_ProtId__Projekt() 2530 fortschritt += delta 2531 wxProgressDialog.Update( value = fortschritt 2532 , newmsg = beschr.replace( '\n', '\ninit__GefszenId_ProtId__Projekt()' ) ) 2533 2534 self.daten__GefszenId_StruktId__Projekt.clear() 2535 self.init__GefszenId_StruktId__Projekt() 2536 fortschritt += delta 2537 wxProgressDialog.Update( value = fortschritt 2538 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2539 2540 self.daten__ProtId_StruktId__Projekt.clear() 2541 self.init__ProtId_StruktId__Projekt() 2542 fortschritt += delta 2543 wxProgressDialog.Update( value = fortschritt 2544 , newmsg = beschr.replace( '\n', '\n' + self.__ProtokolldateiEintrag__ ) ) 2545 2546 2547 2548 # 2549 # -- Fortschrittsanzeige schließen ------------------------------------------ 2550 # 2551 wxProgressDialog.Destroy()

2552 2553 2554 2555 2556 2557 # 2558 # ------------------------------------------------------------------------------------ 2559 # ------------------------------------------------------------------------------------ 2560 # -- Die übergebene >dok_doku_id< suchen ---------------------------------- 2561 # ------------------------------------------------------------------------------------ 2562 # ------------------------------------------------------------------------------------ 2563 #

2564 - def finde__dokDokuId( self, dokDokuId, ignorierePrjProjekteId = False ) :

2565 """Es wird geprüft, ob die übergebene C{dok_doku_id} in der Datenbank zu finden ist. 2566 2567 @param dokDokuId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 2568 @type dokDokuId: Ganzzahl 2569 2570 @param ignorierePrjProjekteId: Es ist die C{True} anzugeben, wenn C{self.filter__prj_projekte_id} in der SQL-Abfrage berücksichtigt werden soll. 2571 @type ignorierePrjProjekteId: Boolean 2572 2573 @return: Es wird eine C{True} zurückgegeben, wenn die C{dok_doku_id} gefunden wurde. Andernfalls C{False}. 2574 @rtype: Python-Liste 2575 """ 2576 2577 # 2578 # -- in Protokolldatei schreiben ------------------------------------------ 2579 # 2580 self.ProtokolldateiEintragen( eintrag = "finde__dokDokuId()" 2581 , istKopfzeile = True ) 2582 2583 2584 2585 # 2586 # -- Dokument vorhanden ? ------------------ 2587 # -- Die Sprache beeinflußt das Abfrageergebnis nicht ------------------ 2588 # 2589 prjProjekteId = self.filter__prj_projekte_id 2590 if( ignorierePrjProjekteId ) : prjProjekteId = None 2591 2592 self.__dbAbfrage__( self.__gibSQL_prjPrtDoku__( prjProjekteId = prjProjekteId 2593 , sprSprachenId = 0 2594 , prtProtokollId = None 2595 , internFirmaId = None 2596 , dokDokuId = dokDokuId 2597 , ignorierePsGefszenarioId = True ) ) 2598 2599 2600 2601 # 2602 # -- Anmerkung wurde nicht gefunden ------------------------------------------ 2603 # 2604 return( self.__gibAnzZeilen__() > 0 )

2605 2606 2607 2608 2609 2610 # 2611 # ------------------------------------------------------------------------------------ 2612 # ------------------------------------------------------------------------------------ 2613 # -- Liste der Einzelwerte zu >prj.zeige__pl_prtpsgefszenario< zurückgeben -- 2614 # ------------------------------------------------------------------------------------ 2615 # ------------------------------------------------------------------------------------ 2616 #

2617 - def gibListePrjPlPrtPsGefszenarioWerte( self, prtProtokollId ):

2618 """ 2619 Methode, die die Datenbank-Identifikationsnummern der Gefahrenszenarien zurückgibt, die innerhalb des vorgegebenen Projektes der angegebenen Protokoll-Id zugeordnet sind. 2620 2621 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 2622 @type prtProtokollId: Ganzzahl(liste) 2623 2624 @return: Es wird C{[prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id]} zurückgegeben. 2625 @rtype: Python-Liste 2626 """ 2627 2628 # 2629 # -- in Protokolldatei schreiben ------------------------------------------ 2630 # 2631 self.ProtokolldateiEintragen( eintrag = "gibListePrjPlPrtPsGefszenarioWerte()" 2632 , istKopfzeile = True ) 2633 2634 2635 2636 # 2637 # -- SQL-Abfrage ausführen -------------------------------------------------- 2638 # 2639 self.__dbAbfrage__( self.__gibSQLSelect__( 2640 select = """ 2641 SELECT DISTINCT 2642 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id""" 2643 , tabellen = [ self.__gibSQLSelect__PlPrtPsGefszenario__( sqlJOIN = None 2644 , sqlWHERE = """ 2645 AND 2646 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id IN( """ + str( prtProtokollId ) + """ ) 2647 AND 2648 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) ) ] ) ) 2649 2650 2651 # 2652 # -- Abfrageergebnis zusammenstellen ---------------------------------- 2653 # 2654 erg = [] 2655 for i in range( self.__gibAnzZeilen__() ): 2656 2657 erg.append( self.__gibWert__( i, 0 ) ) 2658 2659 2660 # 2661 # -- Id's zurückgeben -------------------------------------------------- 2662 # 2663 return erg

2664 2665 2666 2667 2668 2669 2670 2671 # 2672 # ------------------------------------------------------------------------------------ 2673 # ------------------------------------------------------------------------------------ 2674 # -- Liste der Einzelwerte zum Protokolleintrag zurückgeben ------------------ 2675 # ------------------------------------------------------------------------------------ 2676 # ------------------------------------------------------------------------------------ 2677 #

2678 - def gibListePrtProtokollWerte( self, prtProtokollId = None, sqlProjekteIdIN = True ):

2679 """ 2680 Methode, die Datenbank-Identifikationsnummern der gefährdeten Personen zurückgibt. 2681 2682 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 2683 @type prtProtokollId: Ganzzahl(liste) 2684 2685 @param sqlProjekteIdIN: Es ist C{True} anzugeben, wenn C{prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id IN(self.filter__prj_projekte_id)} engegeben werden soll. Bei C{False} wird C{prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_projekte_id NOT IN(self.filter__prj_projekte_id)} verwendet. 2686 @type sqlProjekteIdIN: Ganzzahl 2687 2688 @return: Es wird C{[prj.zeige__prtprotokoll.prt__typ__id, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen, proteintrag, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__datuhrz, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__duanfrage, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__erledigt, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__intern, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_personen_id, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__teilnehmer, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__termin, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__id, prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id, prj.zeige__prtprotokoll.prt__protokoll__id]} zurückgegeben. 2689 @rtype: Python-Liste 2690 """ 2691 2692 # 2693 # -- in Protokolldatei schreiben ------------------------------------------ 2694 # 2695 self.ProtokolldateiEintragen( eintrag = "gibListePrtProtokollWerte()" 2696 , istKopfzeile = True ) 2697 2698 2699 2700 # 2701 # -- SQL-Abfrage ausführen -------------------------------------------------- 2702 # 2703 self.__dbAbfrage__( self.__gibSQL_prjPrtProtokoll__( prtProtokollId = prtProtokollId 2704 , sqlProjekteIdIN = sqlProjekteIdIN ) ) 2705 2706 2707 # 2708 # -- Liste zusammenstellen -------------------------------------------------- 2709 # 2710 erg = [] 2711 for i in range( self.__gibAnzZeilen__() ): 2712 2713 erg.append( [ # -- prj.zeige__prtprotokoll.prt__typ__id 2714 self.__gibWert__( i, 0 ) 2715 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen 2716 , self.__gibWert__( i, 1 ) 2717 # -- proteintrag 2718 , self.__gibWert__( i, 2 ) 2719 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__datuhrz 2720 , self.__gibWert__( i, 3 ) 2721 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__duanfrage 2722 , self.__gibWert__( i, 4 ) 2723 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__erledigt 2724 , self.__gibWert__( i, 5 ) 2725 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__intern 2726 , self.__gibWert__( i, 6 ) 2727 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__prj_personen_id 2728 , self.__gibWert__( i, 7 ) 2729 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__teilnehmer 2730 , self.__gibWert__( i, 8 ) 2731 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__termin 2732 , self.__gibWert__( i, 9 ) 2733 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__id 2734 , self.__gibWert__( i, 10 ) 2735 # -- prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id 2736 , self.__gibWert__( i, 11 ) 2737 # -- prj.zeige__prtprotokoll.prt__protokoll__id 2738 , self.__gibWert__( i, 12 ) ] ) 2739 2740 2741 # 2742 # -- Lste zurückgeben -------------------------------------------------- 2743 # 2744 return erg

2745 2746 2747 2748 2749 # 2750 # ------------------------------------------------------------------------------------ 2751 # ------------------------------------------------------------------------------------ 2752 # -- Liste der aktuell zugeordneten gefährdeten Personen zurückgeben -- 2753 # ------------------------------------------------------------------------------------ 2754 # ------------------------------------------------------------------------------------ 2755 #

2756 - def gibListePsAbkId( self, psAbkTyp ):

2757 """ 2758 Methode, die Datenbank-Identifikationsnummern der gefährdeten Personene zurückgibt. 2759 2760 @param psAbkTyp: Es ist der Typ der Abkürzung (C{ps.abk.typ}) zu übergeben. 2761 @type psAbkTyp: Zeichenkette 2762 """ 2763 2764 # 2765 # -- in Protokolldatei schreiben ------------------------------------------ 2766 # 2767 self.ProtokolldateiEintragen( eintrag = "gibListePsAbkId()" 2768 , istKopfzeile = True ) 2769 2770 2771 2772 # 2773 # -- SQL-Abfrage ausführen -------------------------------------------------- 2774 # 2775 self.__dbAbfrage__( self.__gibSQL_prjPlPsGefabk__() ) 2776 2777 2778 # 2779 # -- Liste zusammenstellen -------------------------------------------------- 2780 # 2781 erg = [] 2782 for i in range( self.__gibAnzZeilen__() ): 2783 typ = self.__gibWert__( i, 0 ) 2784 2785 # 2786 # -- gefährdete Personen -------------------------- 2787 # -- (es werden mehrere Werte gesetzt) -------------------------- 2788 # 2789 if typ == psAbkTyp : 2790 2791 erg.append( self.__gibWert__( i, 1 ) ) 2792 continue 2793 2794 2795 # 2796 # -- Liste zurückgeben -------------------------------------------------- 2797 # 2798 return erg

2799 2800 2801 2802 2803 2804 2805 # 2806 # ------------------------------------------------------------------------------------ 2807 # ------------------------------------------------------------------------------------ 2808 # -- Liste der aktuell zugeordneten Protokolleinträge zurückgeben -- 2809 # ------------------------------------------------------------------------------------ 2810 # ------------------------------------------------------------------------------------ 2811 #

2812 - def gibListePsPrtProtokollWerte( self, prtTypAspekt, prtTypId = None, prtProtokollIdVorg = None ):

2813 """ 2814 Methode, die die Datenbank-Identifikationsnummern der zugeordneten Protokolleinträge zurückgibt. 2815 2816 @param prtTypAspekt: Es ist der Aspekt (PE, SF, TP) des Protokolleintrages (C{prt.typ.aspekte}) zu übergeben. 2817 @type prtTypAspekt: Zeichenkette 2818 2819 @param prtTypId: Es ist die Datenbankidentifikationsnummer (C{prt.typ.id}) des Typs des aktuellen Protokolleintrages zu übergeben. 2820 @type prtTypId: Ganzzahl 2821 2822 @param prtProtokollIdVorg: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 2823 @type prtProtokollIdVorg: Ganzzahl(liste) 2824 2825 @return: Es wird C{[prj.zeige__pl_prtpsgefszenario.prt_protokoll_id]} zurückgegeben. 2826 @rtype: Python-Liste 2827 """ 2828 2829 # 2830 # -- in Protokolldatei schreiben ------------------------------------------ 2831 # 2832 self.ProtokolldateiEintragen( eintrag = "gibListePsPrtProtokollWerte()" 2833 , istKopfzeile = True ) 2834 2835 2836 2837 # 2838 # -- Datenbankabfrage ausführen ------------------------------------------ 2839 # 2840 self.__dbAbfrage__( self.__gibSQL_psPrtProtokoll__( prtTypAspekt = prtTypAspekt 2841 , prtTypId = prtTypId 2842 , sqlINpsGefszenId = True 2843 , prtProtokollIdVorg = prtProtokollIdVorg 2844 , prtProtokollIdNachf = None ) ) 2845 2846 2847 # 2848 # -- Liste zusammenstellen -------------------------------------------------- 2849 # 2850 erg = [] 2851 for i in range( self.__gibAnzZeilen__() ): 2852 2853 if( self.__gibWert__( i, 3 ) in erg ) : 2854 2855 continue 2856 2857 erg.append( # -- prj.zeige__pl_prtpsgefszenario.prt_protokoll_id 2858 self.__gibWert__( i, 3 ) ) 2859 2860 2861 # 2862 # -- Lste zurückgeben -------------------------------------------------- 2863 # 2864 return erg

2865 2866 2867 2868 2869 # 2870 # ------------------------------------------------------------------------------------ 2871 # ------------------------------------------------------------------------------------ 2872 # -- Gefahrenszenario-Id übernehmen ------------------------------------------ 2873 # ------------------------------------------------------------------------------------ 2874 # ------------------------------------------------------------------------------------ 2875 #

2876 - def gib__PsGefszenarioId( self ) :

2877 """ 2878 Methode, die die aktuell gewählte C{ps.gefszenario.id} zurückgibt. 2879 2880 @return: Es wird C{self.ps_gefszenario_id} zurückgegeben. Wenn keine Gefahrenszenarien vorhanden sind, wird C{None} zurückgegeben. 2881 @rtype: Ganzzahl 2882 """ 2883 2884 # 2885 # -- Gefahrenszenario-Id zurückgeben ------------------------------------------ 2886 # 2887 return self.ps_gefszenario_id

2888 2889 2890 2891 # 2892 # ------------------------------------------------------------------------------------ 2893 # ------------------------------------------------------------------------------------ 2894 # -- Permanente Datenstruktur der Dokumente initialisieren ------------------ 2895 # ------------------------------------------------------------------------------------ 2896 # ------------------------------------------------------------------------------------ 2897 #

2898 - def init__dokDoku__Projekt__Sprache( self ):

2899 """ 2900 Es wird die Permanente Datenstruktur C{self.daten__dokDoku__Projekt__Sprache} initialisiert. 2901 """ 2902 2903 # 2904 # -- SQL-Abfrage ausführen und Protokolldatei schreiben ------------------ 2905 # -- wxObjekt und ggf. globale Variable aktualisieren ------------------ 2906 # 2907 self.__initPermDatenstruktur__( protokollDatKopf = "init__dokDoku__Projekt__Sprache()" 2908 , sql = self.__gibSQL_prjPrtDoku__( prjProjekteId = self.filter__prj_projekte_id 2909 , sprSprachenId = self.filter__spr_sprachen_id 2910 , prtProtokollId = None 2911 , internFirmaId = None 2912 , dokDokuId = None 2913 , ignorierePsGefszenarioId = True ) 2914 , permDaten = self.daten__dokDoku__Projekt__Sprache )

2915 2916 2917 2918 2919 2920 # 2921 # ------------------------------------------------------------------------------------ 2922 # ------------------------------------------------------------------------------------ 2923 # -- wxComboBox der Tabelle 'prj.projekte' initialisieren ------------------ 2924 # ------------------------------------------------------------------------------------ 2925 # ------------------------------------------------------------------------------------ 2926 #

2927 - def init__internFirma( self ):

2928 """ 2929 Es wird die Permanente Datenstruktur C{self.daten__internFirma} initialisiert. 2930 """ 2931 2932 # 2933 # -- die globale Variable muß mit Werten gefüllt werden ------------------ 2934 # -- (Datenbankabfrage durchführen) ------------------ 2935 # 2936 self.__initPermDatenstruktur__( protokollDatKopf = "init__internFirma()" 2937 , sql = """ 2938 SELECT 2939 name 2940 , id 2941 FROM 2942 intern.firma 2943 WHERE 2944 idfrei = 0 2945 AND 2946 id > 0 2947 ORDER BY 2948 name 2949 ;""" 2950 , permDaten = self.daten__internFirma )

2951 2952 2953 # 2954 # ------------------------------------------------------------------------------------ 2955 # ------------------------------------------------------------------------------------ 2956 # -- >self.daten__GefszenId_AbkId_gp__Projekt__Sprache< ------------------ 2957 # -- >self.daten__GefszenId_AbkId_rh__Projekt__Sprache< ------------------ 2958 # -- >self.daten__GefszenId_AbkId_rg__Projekt__Sprache< ------------------ 2959 # -- >self.daten__GefszenId_AbkId_rr__Projekt__Sprache< ------------------ 2960 # ------------------------------------------------------------------------------------ 2961 # ------------------------------------------------------------------------------------ 2962 #

2963 - def init__GefszenId_AbkId__Projekt__Sprache( self ):

2964 """ 2965 Es werden die Permanenten Datenstrukturen C{self.daten__GefszenId_AbkId_gp__Projekt__Sprache, self.daten__GefszenId_AbkId_rh__Projekt__Sprache, self.daten__GefszenId_AbkId_rg__Projekt__Sprache, self.daten__GefszenId_AbkId_rr__Projekt__Sprache} initialisiert. 2966 """ 2967 2968 # 2969 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 2970 # -- und ggf. globale Variable aktualisieren ------------------ 2971 # 2972 sql = ( """ 2973 SELECT 2974 -- 0 2975 prj.zeige__pl_psgefabk.ps_gefszenario_id 2976 , prj.zeige__pl_psgefabk.ps_abk_id AS abk_id 2977 -- 2 2978 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS begr 2979 , prj.zeige__pl_psgefabk.notizen 2980 -- 4 2981 , prj.zeige__pl_psgefabk.spr_uebvar_id_zus 2982 FROM 2983 prj.zeige__pl_psgefabk_le 2984 , prj.zeige__pl_psgefabk 2985 LEFT OUTER JOIN spr.zeige__wgruppe 2986 ON ( 2987 prj.zeige__pl_psgefabk.spr_uebvar_id_zus = spr.zeige__wgruppe.spr_uebvar_id 2988 AND 2989 -- 2990 -- Sprache Auswählen 2991 -- 2992 spr.zeige__wgruppe.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 2993 ) 2994 , ps.abk 2995 WHERE 2996 -- 2997 -- Ausschließlich die letzten (aktuellen) Abkürzungen anzeigen, ... 2998 -- 2999 prj.zeige__pl_psgefabk_le.prj__pl_psgefabk__id = prj.zeige__pl_psgefabk.id 3000 AND 3001 -- 3002 -- ... die nicht entfernt wurden 3003 -- 3004 prj.zeige__pl_psgefabk.logentfernt = false 3005 AND 3006 -- 3007 -- Projekt auswählen 3008 -- 3009 prj.zeige__pl_psgefabk.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3010 AND 3011 -- 3012 -- Typ der Abkürzung zuordnen 3013 -- 3014 prj.zeige__pl_psgefabk.ps_abk_id = ps.abk.id 3015 AND 3016 ps.abk.typ = 'GP' 3017 ORDER BY 3018 prj.zeige__pl_psgefabk.ps_gefszenario_id 3019 """ ) 3020 3021 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_AbkId__Projekt__Sprache() - Gefährdete Personen" 3022 , sql = sql 3023 , permDaten = self.daten__GefszenId_AbkId_gp__Projekt__Sprache 3024 , istDict = True ) 3025 3026 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_AbkId__Projekt__Sprache() - Häufigkeit" 3027 , sql = sql.replace( "ps.abk.typ = 'GP'" 3028 , "ps.abk.typ = 'RH'" ) 3029 , permDaten = self.daten__GefszenId_AbkId_rh__Projekt__Sprache 3030 , istDict = True ) 3031 3032 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_AbkId__Projekt__Sprache() - Gefahrenstufe" 3033 , sql = sql.replace( "ps.abk.typ = 'GP'" 3034 , "ps.abk.typ = 'RG'" ) 3035 , permDaten = self.daten__GefszenId_AbkId_rg__Projekt__Sprache 3036 , istDict = True ) 3037 3038 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_AbkId__Projekt__Sprache() - Risikostufe" 3039 , sql = sql.replace( "ps.abk.typ = 'GP'" 3040 , "ps.abk.typ = 'RR'" ) 3041 , permDaten = self.daten__GefszenId_AbkId_rr__Projekt__Sprache 3042 , istDict = True )

3043 3044 3045 3046 3047 3048 # 3049 # ------------------------------------------------------------------------------------ 3050 # ------------------------------------------------------------------------------------ 3051 # -- >daten__GefszenId_AnmId__Projekt__Sprache< initialisieren -- 3052 # ------------------------------------------------------------------------------------ 3053 # ------------------------------------------------------------------------------------ 3054 #

3055 - def init__GefszenId_AnmId__Projekt__Sprache( self ):

3056 """ 3057 Es wird die Permanente Datenstruktur C{self.daten__GefszenId_AnmId__Projekt__Sprache} initialisiert. 3058 """ 3059 3060 # 3061 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3062 # -- und ggf. globale Variable aktualisieren ------------------ 3063 # 3064 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_AnmId__Projekt__Sprache()" 3065 , sql = """ 3066 SELECT DISTINCT 3067 -- 0 3068 prj.pl_psgefanm.ps_gefszenario_id 3069 , prj.pl_psgefanm.ps_anmerkung_id 3070 -- 2 3071 , prj.pl_psgefanm.spr_uebvar_id 3072 , spr.zeige__wgruppe.wgruppe AS zk 3073 -- 4 3074 , prj.pl_psgefanm.notizen 3075 FROM 3076 prj.zeige__pl_psgefanm_le 3077 , prj.pl_psgefanm 3078 LEFT OUTER JOIN spr.zeige__wgruppe 3079 ON ( 3080 prj.pl_psgefanm.spr_uebvar_id = spr.zeige__wgruppe.spr_uebvar_id 3081 AND 3082 -- 3083 -- Sprache Auswählen 3084 -- 3085 spr.zeige__wgruppe.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 3086 ) 3087 WHERE 3088 -- 3089 -- Ausschließlich die letzten (aktuellen) Anmerkungen anzeigen, ... 3090 -- 3091 prj.zeige__pl_psgefanm_le.prj__pl_psgefanm__id = prj.pl_psgefanm.id 3092 AND 3093 -- 3094 -- ... die nicht entfernt wurden 3095 -- 3096 prj.pl_psgefanm.logentfernt = false 3097 AND 3098 -- 3099 -- Projekt auswählen 3100 -- 3101 prj.pl_psgefanm.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3102 ORDER BY 3103 prj.pl_psgefanm.ps_gefszenario_id 3104 , prj.pl_psgefanm.ps_anmerkung_id 3105 ; 3106 """ 3107 , permDaten = self.daten__GefszenId_AnmId__Projekt__Sprache 3108 , istDict = True )

3109 3110 3111 3112 3113 3114 # 3115 # ------------------------------------------------------------------------------------ 3116 # ------------------------------------------------------------------------------------ 3117 # -- >self.daten__GefszenId_ProtId_gefProt__Projekt< und ---------- 3118 # -- >self.daten__GefszenId_ProtId_siAnf__Projekt< initialisieren ---------- 3119 # ------------------------------------------------------------------------------------ 3120 # ------------------------------------------------------------------------------------ 3121 #

3122 - def init__GefszenId_ProtId__Projekt( self ):

3123 """ 3124 Es werden die Permanenten Datenstrukturen C{self.daten__GefszenId_ProtId_gefProt__Projekt, self.daten__GefszenId_ProtId_siAnf__Projekt} initialisiert. 3125 """ 3126 3127 # 3128 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3129 # -- und ggf. globale Variable aktualisieren ------------------ 3130 # 3131 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_ProtId__Projekt() - gefProt" 3132 , sql = """ 3133 SELECT DISTINCT 3134 prj.pl_prtpsgefszenario.ps_gefszenario_id 3135 , prj.pl_prtpsgefszenario.prt_protokoll_id 3136 FROM 3137 prj.pl_prtpsgefszenario 3138 , prj.zeige__pl_prtpsgefszenario_le 3139 , prt.protokoll 3140 WHERE 3141 prj.pl_prtpsgefszenario.id = prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id 3142 AND 3143 prj.pl_prtpsgefszenario.logentfernt = false 3144 AND 3145 prj.pl_prtpsgefszenario.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3146 AND 3147 prj.pl_prtpsgefszenario.prt_protokoll_id = prt.protokoll.id 3148 AND 3149 prt.protokoll.prt_typ_id IN ( """ 3150 + str( self.konstante__prt_typ_id__gefProt ).replace( '[', '' ).replace( ']', '' ) + """ ) 3151 ORDER BY 3152 prj.pl_prtpsgefszenario.ps_gefszenario_id 3153 , prj.pl_prtpsgefszenario.prt_protokoll_id 3154 ; 3155 """ 3156 , permDaten = self.daten__GefszenId_ProtId_gefProt__Projekt 3157 , istDict = True ) 3158 3159 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_ProtId__Projekt() - siAnf" 3160 , sql = """ 3161 SELECT DISTINCT 3162 prj.pl_prtpsgefszenario.ps_gefszenario_id 3163 , prj.pl_prtpsgefszenario.prt_protokoll_id 3164 FROM 3165 prj.pl_prtpsgefszenario 3166 , prj.zeige__pl_prtpsgefszenario_le 3167 , prt.protokoll 3168 WHERE 3169 prj.pl_prtpsgefszenario.id = prj.zeige__pl_prtpsgefszenario_le.prj__pl_prtpsgefszenario__id 3170 AND 3171 prj.pl_prtpsgefszenario.logentfernt = false 3172 AND 3173 prj.pl_prtpsgefszenario.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3174 AND 3175 prj.pl_prtpsgefszenario.prt_protokoll_id = prt.protokoll.id 3176 AND 3177 prt.protokoll.prt_typ_id IN ( """ 3178 + str( self.konstante__prt_typ_id__siAnf ).replace( '[', '' ).replace( ']', '' ) + """ ) 3179 ORDER BY 3180 prj.pl_prtpsgefszenario.ps_gefszenario_id 3181 , prj.pl_prtpsgefszenario.prt_protokoll_id 3182 ; 3183 """ 3184 , permDaten = self.daten__GefszenId_ProtId_siAnf__Projekt 3185 , istDict = True )

3186 3187 3188 3189 3190 # 3191 # ------------------------------------------------------------------------------------ 3192 # ------------------------------------------------------------------------------------ 3193 # -- >daten__GefszenId_StruktId__Projekt< initialisieren ------------------ 3194 # ------------------------------------------------------------------------------------ 3195 # ------------------------------------------------------------------------------------ 3196 #

3197 - def init__GefszenId_StruktId__Projekt( self ):

3198 """ 3199 Es wird die Permanente Datenstruktur C{self.daten__GefszenId_StruktId__Projekt} initialisiert. 3200 """ 3201 3202 # 3203 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3204 # -- und ggf. globale Variable aktualisieren ------------------ 3205 # 3206 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_StruktId__Projekt()" 3207 , sql = """ 3208 SELECT DISTINCT 3209 prj.zeige__pl_psgefstrkt.ps_gefszenario_id 3210 , prj.zeige__pl_psgefstrkt.str_strkt_id 3211 FROM 3212 prj.zeige__pl_psgefstrkt 3213 , prj.zeige__pl_psgefstrkt_le 3214 WHERE 3215 prj.zeige__pl_psgefstrkt.id = prj.zeige__pl_psgefstrkt_le.prj__pl_psgefstrkt__id 3216 AND 3217 prj.zeige__pl_psgefstrkt.logentfernt = false 3218 AND 3219 prj.zeige__pl_psgefstrkt.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3220 ORDER BY 3221 prj.zeige__pl_psgefstrkt.ps_gefszenario_id 3222 , prj.zeige__pl_psgefstrkt.str_strkt_id 3223 ; 3224 """ 3225 , permDaten = self.daten__GefszenId_StruktId__Projekt 3226 , istDict = True )

3227 3228 3229 3230 3231 # 3232 # ------------------------------------------------------------------------------------ 3233 # ------------------------------------------------------------------------------------ 3234 # -- >daten__GefszenId_Wortgruppen__Projekt__Sprache< initialisieren -- 3235 # ------------------------------------------------------------------------------------ 3236 # ------------------------------------------------------------------------------------ 3237 #

3238 - def init__GefszenId_Wortgruppen__Projekt__Sprache( self ):

3239 """ 3240 Es wird die Permanente Datenstruktur C{self.daten__GefszenId_Wortgruppen__Projekt__Sprache} initialisiert. 3241 """ 3242 3243 # 3244 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3245 # -- und ggf. globale Variable aktualisieren ------------------ 3246 # 3247 self.__initPermDatenstruktur__( protokollDatKopf = "init__GefszenId_Wortgruppen__Projekt__Sprache()" 3248 , sql = """ 3249 SELECT DISTINCT 3250 -- 0 3251 prj.pp_psgefszenario.id 3252 , prj.pp_psgefszenario.spr_uebvar_id 3253 -- 2 3254 , COALESCE( gefszen.wgruppe, '??' ) AS gefszen 3255 , prj.pp_psgefszenario.notizen 3256 -- 4 3257 , prj.pp_psgefszenario.spr_uebvar_id_reprgefszen 3258 , COALESCE( reprgefszen.wgruppe, '??' ) AS reprgefszen 3259 -- 6 3260 -- , prj.pp_psgefszenario.spr_uebvar_id_ursp 3261 -- , COALESCE( ursp.wgruppe, '??' ) AS ursp 3262 FROM 3263 prj.pp_psgefszenario 3264 LEFT OUTER JOIN spr.zeige__wgruppe AS gefszen 3265 ON ( 3266 prj.pp_psgefszenario.spr_uebvar_id = gefszen.spr_uebvar_id 3267 AND 3268 -- 3269 -- Sprache Auswählen 3270 -- 3271 gefszen.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 3272 ) 3273 LEFT OUTER JOIN spr.zeige__wgruppe AS reprgefszen 3274 ON ( 3275 prj.pp_psgefszenario.spr_uebvar_id_reprgefszen = reprgefszen.spr_uebvar_id 3276 AND 3277 -- 3278 -- Sprache Auswählen 3279 -- 3280 reprgefszen.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 3281 ) 3282 -- LEFT OUTER JOIN spr.zeige__wgruppe AS ursp 3283 -- ON ( 3284 -- prj.pp_psgefszenario.spr_uebvar_id_ursp = ursp.spr_uebvar_id 3285 -- AND 3286 -- -- 3287 -- -- Sprache Auswählen 3288 -- -- 3289 -- ursp.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 3290 -- ) 3291 WHERE 3292 -- 3293 -- Projekt auswählen 3294 -- 3295 prj.pp_psgefszenario.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3296 ; 3297 """ 3298 , permDaten = self.daten__GefszenId_Wortgruppen__Projekt__Sprache 3299 , istDict = True )

3300 3301 3302 3303 3304 3305 # 3306 # ------------------------------------------------------------------------------------ 3307 # ------------------------------------------------------------------------------------ 3308 # -- >self.daten__ProtId_DatUhrz_aufgabe__Projekt< -- 3309 # -- >self.daten__ProtId_DatUhrz_teilnehmer__Projekt< initialisieren -- 3310 # ------------------------------------------------------------------------------------ 3311 # ------------------------------------------------------------------------------------ 3312 #

3313 - def init__ProtId_DatUhrz__Projekt( self ):

3314 """ 3315 Es werden die Permanenten Datenstrukturen C{self.daten__ProtId_DatUhrz_aufgabe__Projekt, self.daten__ProtId_DatUhrz_teilnehmer__Projekt} initialisiert. 3316 """ 3317 3318 # 3319 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3320 # -- und ggf. globale Variable aktualisieren ------------------ 3321 # 3322 sql = ( """ 3323 SELECT DISTINCT 3324 prj.pp_prtprotokoll.prt_protokoll_id 3325 , to_char( prj.pp_prtprotokoll.termin, 'DD.MM.YYYY' ) 3326 , to_char( prj.pp_prtprotokoll.duanfrage, 'DD.MM.YYYY' ) 3327 FROM 3328 prj.pp_prtprotokoll 3329 , prt.protokoll 3330 WHERE 3331 -- 3332 -- Projekt einschränken 3333 -- 3334 prj.pp_prtprotokoll.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3335 AND 3336 -- 3337 -- Typ einschränken 3338 -- 3339 prj.pp_prtprotokoll.prt_protokoll_id = prt.protokoll.id 3340 AND 3341 prt.protokoll.prt_typ_id IN( """ 3342 + str( self.konstante__prt_typ_id__gefProt ).replace( '[', '' ).replace( ']', '' ) + """ ) 3343 AND 3344 -- 3345 -- Teilnehmer ( = 0 ) / Aufgabe an ... ( > 0 ) 3346 -- 3347 prj.pp_prtprotokoll.prj_personen_id > 0 3348 AND 3349 -- 3350 -- Teilnehmer (NULL) / Aufgabe an ... (false) 3351 -- 3352 prj.pp_prtprotokoll.teilnehmer = false 3353 ORDER BY 3354 prj.pp_prtprotokoll.prt_protokoll_id 3355 ; 3356 """ ) 3357 3358 self.__initPermDatenstruktur__( protokollDatKopf = "init__ProtId_DatUhrz__Projekt() - Aufgabe" 3359 , sql = sql 3360 , permDaten = self.daten__ProtId_DatUhrz_aufgabe__Projekt 3361 , istDict = True ) 3362 3363 sql = sql.replace( """ 3364 , to_char( prj.pp_prtprotokoll.termin, 'DD.MM.YYYY' ) 3365 , to_char( prj.pp_prtprotokoll.duanfrage, 'DD.MM.YYYY' ) 3366 """ 3367 , """ 3368 , to_char( prj.pp_prtprotokoll.datuhrz, 'DD.MM.YYYY' ) 3369 , prj.pp_prtprotokoll.erledigt 3370 , prj.pp_prtprotokoll.intern 3371 , prt.protokoll.prt_typ_id 3372 """ ) 3373 3374 sql = sql.replace( """ 3375 prj.pp_prtprotokoll.prj_personen_id > 0 3376 """ 3377 , """ 3378 prj.pp_prtprotokoll.prj_personen_id = 0 3379 """ ) 3380 3381 3382 sql = sql.replace( """ 3383 prj.pp_prtprotokoll.teilnehmer = false 3384 """ 3385 , """ 3386 prj.pp_prtprotokoll.teilnehmer IS NULL 3387 """ ) 3388 3389 self.__initPermDatenstruktur__( protokollDatKopf = "init__ProtId_DatUhrz__Projekt() - Teilnehmer" 3390 , sql = sql.replace( "prj.pp_prtprotokoll.teilnehmer = false" 3391 , "prj.pp_prtprotokoll.teilnehmer = true" ) 3392 , permDaten = self.daten__ProtId_DatUhrz_teilnehmer__Projekt 3393 , istDict = True )

3394 3395 3396 3397 3398 # 3399 # ------------------------------------------------------------------------------------ 3400 # ------------------------------------------------------------------------------------ 3401 # -- >self.daten__ProtId_DokuId__Projekt< initialisieren ------------------ 3402 # ------------------------------------------------------------------------------------ 3403 # ------------------------------------------------------------------------------------ 3404 #

3405 - def init__ProtId_DokuId__Projekt( self ):

3406 """ 3407 Es wird die Permanente Datenstruktur C{self.daten__ProtId_DokuId__Projekt} initialisiert. 3408 """ 3409 3410 # 3411 # -- Filterbedingung setzen -------------------------------------------------- 3412 # 3413 3414 # 3415 # -- Dokument -------------------------------------------------- 3416 # 3417 filterDokument = self.__gibFilterZusKrit__Id__( filterKrit = HK_DOK ) 3418 3419 if( len( filterDokument ) > 0 ) : 3420 3421 filterDokument = """ 3422 AND 3423 prj.pl_prtdokdoku.dok_doku_id IN( """ + filterDokument + """ )""" 3424 3425 3426 3427 # 3428 # -- Ersteller des Dokumentes (Firma) ---------------------------------- 3429 # 3430 filterFirmaFROM = "" 3431 filterFirma = self.__gibFilterZusKrit__Id__( filterKrit = HK_INTERNFIRMA ) 3432 3433 if( len( filterFirma ) > 0 ) : 3434 3435 filterFirmaFROM = """ 3436 , dok.doku""" 3437 3438 filterFirma = """ 3439 AND 3440 prj.pl_prtdokdoku.dok_doku_id = dok.doku.id 3441 AND 3442 dok.doku.idfrei = 0 3443 AND 3444 dok.doku.intern_firma_id IN( """ + filterFirma + """ )""" 3445 3446 3447 3448 # 3449 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3450 # -- und ggf. globale Variable aktualisieren ------------------ 3451 # 3452 self.__initPermDatenstruktur__( protokollDatKopf = "init__ProtId_DokuId__Projekt()" 3453 , sql = """ 3454 SELECT DISTINCT 3455 prj.pl_prtdokdoku.prt_protokoll_id 3456 , prj.pl_prtdokdoku.dok_doku_id 3457 FROM 3458 prj.pl_prtdokdoku 3459 , prj.zeige__pl_prtdokdoku_le""" + filterFirmaFROM + """ 3460 WHERE 3461 prj.pl_prtdokdoku.dok_doku_id = prj.zeige__pl_prtdokdoku_le.prj__pl_prtdokdoku__id 3462 AND 3463 prj.pl_prtdokdoku.logentfernt = false""" 3464 + filterDokument + """ 3465 AND 3466 prj.pl_prtdokdoku.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) 3467 + filterFirma + """ 3468 ORDER BY 3469 prj.pl_prtdokdoku.prt_protokoll_id 3470 , prj.pl_prtdokdoku.dok_doku_id 3471 ; 3472 """ 3473 , permDaten = self.daten__ProtId_DokuId__Projekt 3474 , istDict = True )

3475 3476 3477 3478 3479 3480 # 3481 # ------------------------------------------------------------------------------------ 3482 # ------------------------------------------------------------------------------------ 3483 # -- >self.daten__ProtId_PersId_aufgabe__Projekt< ---------- 3484 # -- >self.daten__ProtId_PersId_teilnehmer__Projekt< initialisieren ---------- 3485 # ------------------------------------------------------------------------------------ 3486 # ------------------------------------------------------------------------------------ 3487 #

3488 - def init__ProtId_PersId__Projekt( self ):

3489 """ 3490 Es werden die Permanenten Datenstrukturen C{self.daten__ProtId_PersId_aufgabe__Projekt, self.daten__ProtId_PersId_teilnehmer__Projekt} initialisiert. 3491 """ 3492 3493 # 3494 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3495 # -- und ggf. globale Variable aktualisieren ------------------ 3496 # 3497 sql = ( """ 3498 SELECT DISTINCT 3499 prj.pp_prtprotokoll.prt_protokoll_id 3500 , prj.pp_prtprotokoll.prj_personen_id 3501 FROM 3502 prj.pp_prtprotokoll 3503 , prt.protokoll 3504 WHERE 3505 -- 3506 -- Projekt einschränken 3507 -- 3508 prj.pp_prtprotokoll.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3509 AND 3510 -- 3511 -- Typ einschränken 3512 -- 3513 prj.pp_prtprotokoll.prt_protokoll_id = prt.protokoll.id 3514 AND 3515 prt.protokoll.prt_typ_id IN( """ 3516 + str( self.konstante__prt_typ_id__gefProt ).replace( '[', '' ).replace( ']', '' ) + """ ) 3517 AND 3518 -- 3519 -- Personen anzeigen 3520 -- 3521 prj.pp_prtprotokoll.prj_personen_id > 0 3522 AND 3523 -- 3524 -- Teilnehmer (true) / Aufgabe an ... (false) 3525 -- 3526 prj.pp_prtprotokoll.teilnehmer = false 3527 ORDER BY 3528 prj.pp_prtprotokoll.prt_protokoll_id 3529 , prj.pp_prtprotokoll.prj_personen_id 3530 ; 3531 """ ) 3532 3533 self.__initPermDatenstruktur__( protokollDatKopf = "init__ProtId_PersId__Projekt() - Aufgabe" 3534 , sql = sql 3535 , permDaten = self.daten__ProtId_PersId_aufgabe__Projekt 3536 , istDict = True ) 3537 3538 self.__initPermDatenstruktur__( protokollDatKopf = "init__ProtId_PersId__Projekt() - Teilnehmer" 3539 , sql = sql.replace( "prj.pp_prtprotokoll.teilnehmer = false" 3540 , "prj.pp_prtprotokoll.teilnehmer = true" ) 3541 , permDaten = self.daten__ProtId_PersId_teilnehmer__Projekt 3542 , istDict = True )

3543 3544 3545 3546 3547 3548 # 3549 # ------------------------------------------------------------------------------------ 3550 # ------------------------------------------------------------------------------------ 3551 # -- >self.daten__ProtId_StruktId__Projekt< initialisieren ------------------ 3552 # ------------------------------------------------------------------------------------ 3553 # ------------------------------------------------------------------------------------ 3554 #

3555 - def init__ProtId_StruktId__Projekt( self ):

3556 """ 3557 Es wird die Permanente Datenstruktur C{self.daten__ProtId_StruktId__Projekt} initialisiert. 3558 """ 3559 3560 # 3561 # -- Filterbedingung setzen -------------------------------------------------- 3562 # 3563 3564 # 3565 # -- Strukturpunkt -------------------------------------------------- 3566 # 3567 filterStrPkt = self.__gibFilterZusKrit__Id__( filterKrit = HK_STR ) 3568 3569 if( len( filterStrPkt ) > 0 ) : 3570 3571 filterStrPkt = """ 3572 AND 3573 prj.p_prtstrstrkt.str_strkt_id IN( """ + filterStrPkt + """ )""" 3574 3575 # 3576 # -- Strukturbezeichnung -------------------------------------------------- 3577 # 3578 filterStrBezFROM = "" 3579 filterStrBez = self.__gibFilterZusKrit__Id__( filterKrit = HK_STRBEZ ) 3580 3581 if( len( filterStrBez ) > 0 ) : 3582 3583 filterStrBezFROM = """ 3584 , str.strkt""" 3585 3586 filterStrBez = """ 3587 AND 3588 prj.p_prtstrstrkt.str_strkt_id = str.strkt.id 3589 AND 3590 str.strkt.idfrei = 0 3591 AND 3592 str.strkt.str_name_id IN( """ + filterStrBez + """ )""" 3593 3594 3595 3596 # 3597 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3598 # -- und ggf. globale Variable aktualisieren ------------------ 3599 # 3600 self.__initPermDatenstruktur__( protokollDatKopf = "init__ProtId_StruktId__Projekt()" 3601 , sql = """ 3602 SELECT DISTINCT 3603 prj.p_prtstrstrkt.prt_protokoll_id 3604 , prj.p_prtstrstrkt.str_strkt_id 3605 FROM 3606 prj.p_prtstrstrkt""" + filterStrBezFROM + """ 3607 WHERE 3608 prj.p_prtstrstrkt.idfrei = 0""" 3609 + filterStrPkt + """ 3610 AND 3611 prj.p_prtstrstrkt.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) 3612 + filterStrBez + """ 3613 ORDER BY 3614 prj.p_prtstrstrkt.prt_protokoll_id 3615 , prj.p_prtstrstrkt.str_strkt_id 3616 ; 3617 """ 3618 , permDaten = self.daten__ProtId_StruktId__Projekt 3619 , istDict = True )

3620 3621 3622 3623 3624 3625 # 3626 # ------------------------------------------------------------------------------------ 3627 # ------------------------------------------------------------------------------------ 3628 # -- >self.daten__prtProtokoll_gefProt__Projekt__Sprache<, -- 3629 # -- >self.daten__prtProtokoll_gefProt_vorg__Projekt__Sprache<, -- 3630 # -- >self.daten__prtProtokoll_siAnf__Projekt__Sprache<, -- 3631 # -- >self.daten__prtProtokoll_siAnf_vorg__Projekt__Sprache< und -- 3632 # -- >self.daten__prtProtokoll_siAnf_gefProt__Projekt__Sprache< initialisieren 3633 # ------------------------------------------------------------------------------------ 3634 # ------------------------------------------------------------------------------------ 3635 #

3636 - def init__prtProtokoll__Projekt__Sprache( self ):

3637 """ 3638 Es werden die Permanenten Datenstrukturen C{self.daten__prtProtokoll_gefProt__Projekt__Sprache, self.daten__prtProtokoll_gefProt_vorg__Projekt__Sprache, self.daten__prtProtokoll_siAnf__Projekt__Sprache, self.daten__prtProtokoll_siAnf__Projekt__Sprache} initialisiert. 3639 """ 3640 3641 # 3642 # -- Filterbedingung setzen -------------------------------------------------- 3643 # 3644 3645 # 3646 # -- Gefahrenprotokolleintrag ------------------------------------------ 3647 # 3648 filterGefProt = self.__gibFilterZusKrit__Id__( filterKrit = HK_PE ) 3649 3650 if( len( filterGefProt ) > 0 ) : 3651 3652 filterGefProt = """AND 3653 prj.pp_prtprotokoll.prt_protokoll_id IN( """ + filterGefProt + """ )""" 3654 3655 3656 3657 # 3658 # -- Sicherheitsanforderung ------------------------------------------ 3659 # 3660 filterSiAnf = self.__gibFilterZusKrit__Id__( filterKrit = HK_SIANF ) 3661 3662 if( len( filterSiAnf ) > 0 ) : 3663 3664 filterSiAnf = """AND 3665 prj.pp_prtprotokoll.prt_protokoll_id IN( """ + filterSiAnf + """ )""" 3666 3667 3668 3669 # 3670 # -- Typ des Gefahrenprotkolleintrages / Sicherheitsanforderung ---------- 3671 # 3672 konstante__gefProt = self.__gibFilterZusKrit__Id__( filterKrit = HK_PETYP ) 3673 if( len( konstante__gefProt ) == 0 ) : 3674 konstante__gefProt = str( self.konstante__prt_typ_id__gefProt ).replace( '[', '' ).replace( ']', '' ) 3675 3676 konstante__siAnf = self.__gibFilterZusKrit__Id__( filterKrit = HK_SIANFTYP ) 3677 if( len( konstante__siAnf ) == 0 ) : 3678 konstante__siAnf = str( self.konstante__prt_typ_id__siAnf ).replace( '[', '' ).replace( ']', '' ) 3679 3680 3681 3682 # 3683 # -- Protokolleinträge (GefProt / SiAnf) auslesen ------------------ 3684 # -- ------------------ 3685 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3686 # -- und ggf. globale Variable aktualisieren ------------------ 3687 # 3688 sql = """ 3689 SELECT DISTINCT 3690 -- 0 3691 prj.pp_prtprotokoll.prt_protokoll_id 3692 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS psanf 3693 -- 2 3694 , prj.pp_prtprotokoll.notizen 3695 , prt.protokoll.prt_typ_id 3696 -- 4 3697 , prj.pp_prtprotokoll.spr_uebvar_id 3698 FROM 3699 prj.pp_prtprotokoll 3700 -- 3701 -- Sicherheitsanforderung 3702 -- 3703 LEFT OUTER JOIN spr.zeige__wgruppe 3704 ON ( 3705 prj.pp_prtprotokoll.spr_uebvar_id = spr.zeige__wgruppe.spr_uebvar_id 3706 AND 3707 -- 3708 -- Sprache Auswählen 3709 -- 3710 spr.zeige__wgruppe.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 3711 ) 3712 , prt.protokoll 3713 WHERE 3714 prj.pp_prtprotokoll.spr_uebvar_id > 0 3715 AND 3716 -- 3717 -- Projekt einschränken 3718 -- 3719 prj.pp_prtprotokoll.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3720 -- Platzhalter für zus. Filterkrit 3721 AND 3722 -- 3723 -- Typ einschränken 3724 -- 3725 prj.pp_prtprotokoll.prt_protokoll_id = prt.protokoll.id 3726 AND 3727 prt.protokoll.prt_typ_id IN( """ + konstante__gefProt + """ ) 3728 ORDER BY 3729 prj.pp_prtprotokoll.prt_protokoll_id 3730 """ 3731 3732 3733 self.__initPermDatenstruktur__( protokollDatKopf = "init__prtProtokoll__Projekt__Sprache() - gefProt" 3734 , sql = sql.replace( '-- Platzhalter für zus. Filterkrit', filterGefProt ) 3735 , permDaten = self.daten__prtProtokoll_gefProt__Projekt__Sprache 3736 , istDict = True ) 3737 3738 3739 self.__initPermDatenstruktur__( protokollDatKopf = "init__prtProtokoll__Projekt__Sprache() - siAnf" 3740 , sql = sql.replace( 'prt.protokoll.prt_typ_id IN( ' + konstante__gefProt, 'prt.protokoll.prt_typ_id IN( ' + konstante__siAnf ).replace( '-- Platzhalter für zus. Filterkrit', filterSiAnf ) 3741 , permDaten = self.daten__prtProtokoll_siAnf__Projekt__Sprache 3742 , istDict = True ) 3743 3744 3745 3746 3747 # 3748 # -- Verbindungen zwischen gleichen Protokolleinträgen (GefProt / SiAnf) -- 3749 # -- auslesen. 3750 # -- -- 3751 # -- SQL-Abfrage ausführen, Protokolldatei schreiben -- 3752 # -- und ggf. globale Variable aktualisieren -- 3753 # 3754 sql = """ 3755 SELECT DISTINCT 3756 -- 0 3757 prj.zeige__p_prtverbindung.prt_protokoll_id_nachf 3758 , CASE WHEN( prt.protokoll.prt_typ_id IS NULL ) 3759 THEN 0 3760 ELSE prj.zeige__p_prtverbindung.prt_protokoll_id_vorg 3761 END AS prt_protokoll_id_vorg 3762 FROM 3763 prj.zeige__p_prtverbindung 3764 -- 3765 -- Typ des Vorgängers ermitteln 3766 -- 3767 LEFT OUTER JOIN prt.protokoll 3768 ON ( 3769 prj.zeige__p_prtverbindung.prt_protokoll_id_vorg = prt.protokoll.id 3770 AND 3771 -- 3772 -- Typ einschränken 3773 -- 3774 prt.protokoll.prt_typ_id IN( """ + konstante__gefProt + """ ) 3775 ) 3776 WHERE 3777 -- 3778 -- Projekt einschränken 3779 -- 3780 prj.zeige__p_prtverbindung.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 3781 AND 3782 -- 3783 -- Typ einschränken 3784 -- 3785 prj.zeige__p_prtverbindung.prt_typ_id_nachf IN( """ + konstante__gefProt + """ ) 3786 ORDER BY 3787 prt_protokoll_id_vorg 3788 , prj.zeige__p_prtverbindung.prt_protokoll_id_nachf 3789 ;""" 3790 3791 self.__initPermDatenstruktur__( protokollDatKopf = "init__prtProtokoll__Projekt__Sprache() - gefProt (Verbindungen)" 3792 , sql = sql 3793 , permDaten = self.daten__prtProtokoll_gefProt_vorg__Projekt__Sprache 3794 , istDict = True ) 3795 3796 self.__initPermDatenstruktur__( protokollDatKopf = "init__prtProtokoll__Projekt__Sprache() - siAnf (Verbindungen)" 3797 , sql = sql.replace( 'prt.protokoll.prt_typ_id IN( ' + konstante__gefProt, 'prt.protokoll.prt_typ_id IN( ' + konstante__siAnf ) 3798 , permDaten = self.daten__prtProtokoll_siAnf_vorg__Projekt__Sprache 3799 , istDict = True ) 3800 3801 3802 # 3803 # -- Verbindungen zwischen SiAnf und GefProt auslesen. ------------------ 3804 # -- ------------------ 3805 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 3806 # -- und ggf. globale Variable aktualisieren ------------------ 3807 # 3808 sql = sql.replace( """ 3809 prj.zeige__p_prtverbindung.prt_protokoll_id_nachf 3810 , CASE WHEN( prt.protokoll.prt_typ_id IS NULL ) 3811 THEN 0 3812 ELSE prj.zeige__p_prtverbindung.prt_protokoll_id_vorg 3813 END AS prt_protokoll_id_vorg 3814 """, """ 3815 CASE WHEN( prt.protokoll.prt_typ_id IS NULL ) 3816 THEN 0 3817 ELSE prj.zeige__p_prtverbindung.prt_protokoll_id_vorg 3818 END AS prt_protokoll_id_vorg 3819 , prj.zeige__p_prtverbindung.prt_protokoll_id_nachf 3820 """ ) 3821 3822 sql = sql.replace( "prt.protokoll.prt_typ_id IN( " + konstante__gefProt + " )" 3823 , "prt.protokoll.prt_typ_id IN( " + konstante__siAnf + " )" ) 3824 3825 sql = sql.replace( "ORDER BY" 3826 , """AND 3827 prt.protokoll.prt_typ_id IS NOT NULL 3828 ORDER BY""" ) 3829 3830 self.__initPermDatenstruktur__( protokollDatKopf = "init__prtProtokoll__Projekt__Sprache() - Verbindung siAnf - GefProt" 3831 , sql = sql 3832 , permDaten = self.daten__prtProtokoll_siAnf_gefProt__Projekt__Sprache 3833 , istDict = True )

3834 3835 3836 3837 3838 # 3839 # ------------------------------------------------------------------------------------ 3840 # ------------------------------------------------------------------------------------ 3841 # -- wxListBox der Tabelle 'prj.personen' initialisieren ------------------ 3842 # ------------------------------------------------------------------------------------ 3843 # ------------------------------------------------------------------------------------ 3844 #

3845 - def init__prjPersonen( self, wxListBox ):

3846 """ 3847 Methode zur Initialisierung der Auswahlliste (C{wxListBox}), die die in der Datenbank verfügbaren Personen aufnimmt (darstellt). 3848 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 3849 3850 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 3851 3852 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Personen aufnimmt. Sie darf C{None} sein. In diesem Fall wird C{self.daten__prjPersonen} aktualisiert (wenn es selber C{None} ist). 3853 @type wxListBox: wxPython - ComboBox 3854 """ 3855 3856 # 3857 # -- die globale Variable muß mit Werten gefüllt werden ------------------ 3858 # -- (Datenbankabfrage durchführen) ------------------ 3859 # 3860 self.__initPermDatenstruktur__( protokollDatKopf = "init__prjPersonen()" 3861 , sql = """ 3862 SELECT 3863 name_n || ', ' || name_v 3864 , id 3865 FROM 3866 prj.personen 3867 WHERE 3868 idfrei = 0 3869 AND 3870 id > 0 3871 ORDER BY 3872 name_n 3873 , name_v 3874 ;""" 3875 , permDaten = self.daten__prjPersonen ) 3876 3877 3878 3879 # 3880 # -- dem >wxObjekt< die Werte der globalen Variable übergeben ---------- 3881 # 3882 self.init__WxControlWithItemsPerm( permDaten = self.daten__prjPersonen 3883 , wxObjekt = wxListBox )

3884 3885 3886 3887 3888 # 3889 # ------------------------------------------------------------------------------------ 3890 # ------------------------------------------------------------------------------------ 3891 # -- wxComboBox der Tabelle 'prj.projekte' initialisieren ------------------ 3892 # ------------------------------------------------------------------------------------ 3893 # ------------------------------------------------------------------------------------ 3894 #

3895 - def init__prjProjekte( self, wxComboBox ):

3896 """ 3897 Methode zur Initialisierung der Auswahlliste (C{wxComboBox}), welche die in der Datenbank verfügbaren Projekte aufnimmt (darstellt). 3898 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 3899 Es ist momentan nicht sinnvoll, die projektübergreifend gültigen Werte anzuzeigen. 3900 3901 @note: Die übergebene Auswahlliste (C{wxComboBox}) wird verändert ! 3902 3903 @param wxComboBox: Es ist die Auswahlliste zu übergeben, die die Projekte aufnimmt. 3904 @type wxComboBox: wxPython - ComboBox 3905 """ 3906 3907 # 3908 # gültige SQL-Abfrage erzeugen, 3909 # die gelesenen Werte der ComboBox zuordnen und 3910 # den ersten Eintrag auswählen 3911 # 3912 self.__initPermDatenstruktur__( protokollDatKopf = "init__prjProjekte()" 3913 , sql = """ 3914 SELECT 3915 prjname 3916 , id 3917 FROM 3918 prj.projekte 3919 WHERE 3920 idfrei = 0 3921 AND 3922 id > 0 3923 AND 3924 prjname NOT LIKE 'DBDokumentation' 3925 ORDER BY 3926 prjname 3927 ;""" 3928 , permDaten = self.daten__prjProjekte ) 3929 3930 3931 3932 # 3933 # -- dem >wxObjekt< die Werte der globalen Variable übergeben ---------- 3934 # 3935 self.init__WxControlWithItemsPerm( permDaten = self.daten__prjProjekte 3936 , wxObjekt = wxComboBox )

3937 3938 3939 3940 3941 # 3942 # ------------------------------------------------------------------------------------ 3943 # ------------------------------------------------------------------------------------ 3944 # -- wxControlWithItems der Tabelle 'prt.typ' initialisieren ------------------ 3945 # ------------------------------------------------------------------------------------ 3946 # ------------------------------------------------------------------------------------ 3947 #

3948 - def init__prtTyp__Sprache( self ):

3949 """ 3950 Es wird die Permanente Datenstruktur C{self.daten__prtTyp__Sprache} initialisiert. 3951 """ 3952 3953 # 3954 # -- die globale Variable muß mit Werten gefüllt werden ------------------ 3955 # -- (Datenbankabfrage durchführen) ------------------ 3956 # 3957 self.__initPermDatenstruktur__( protokollDatKopf = "init__prtTyp__Sprache()" 3958 , sql = """ 3959 SELECT DISTINCT 3960 COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS typ 3961 , prt.typ.id 3962 , prt.typ.aspekt 3963 FROM 3964 prt.typ 3965 LEFT OUTER JOIN spr.zeige__wgruppe ON ( 3966 prt.typ.spr_uebvar_id = spr.zeige__wgruppe.spr_uebvar_id 3967 AND 3968 -- 3969 -- Sprache Auswählen 3970 -- 3971 spr.zeige__wgruppe.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 3972 ) 3973 WHERE 3974 prt.typ.idfrei = 0 3975 AND 3976 prt.typ.id > 0 3977 ORDER BY 3978 prt.typ.aspekt 3979 , typ 3980 ;""" 3981 , permDaten = self.daten__prtTyp__Sprache )

3982 3983 3984 3985 3986 # 3987 # ------------------------------------------------------------------------------------ 3988 # ------------------------------------------------------------------------------------ 3989 # -- >self.daten__psAbk__Projekt__Sprache< initialisieren ------------------ 3990 # ------------------------------------------------------------------------------------ 3991 # ------------------------------------------------------------------------------------ 3992 #

3993 - def init__psAbk__Projekt__Sprache( self, ComboBoxErg_ListBoxSpWTitelAL, psAbkTyp ):

3994 """ 3995 Es wird die Permanente Datenstruktur C{self.daten__psAbk__Projekt__Sprache} initialisiert. 3996 3997 @note: Die übergebene Liste (C{ComboBoxErg_ListBoxSpWTitelAL}) wird verändert ! 3998 3999 @param ComboBoxErg_ListBoxSpWTitelAL: Es ist die Auswahlliste zu übergeben, die die Abkürzungen aufnimmt. 4000 @type ComboBoxErg_ListBoxSpWTitelAL: ComboBoxErg oder ListBoxSpWTitelAL 4001 4002 @param psAbkTyp: Es ist der Typ C{ps.abk.typ} der Abkürzung anzugeben. 4003 @type psAbkTyp: Zeichenkette 4004 """ 4005 4006 # 4007 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 4008 # -- und ggf. globale Variable aktualisieren ------------------ 4009 # 4010 self.__initPermDatenstruktur__( protokollDatKopf = "init__psAbk__Projekt__Sprache()" 4011 , sql = """ 4012 SELECT DISTINCT 4013 -- 0 4014 prj.zeige__psabk.ps__abk__typ 4015 , COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS abkuerzung 4016 -- 2 4017 , prj.zeige__psabk.ps__abk__id 4018 FROM 4019 prj.zeige__psabk 4020 LEFT OUTER JOIN spr.zeige__wgruppe 4021 ON ( 4022 prj.zeige__psabk.prj__p_psabk__spr_uebvar_id = spr.zeige__wgruppe.spr_uebvar_id 4023 AND 4024 -- 4025 -- Sprache Auswählen 4026 -- 4027 spr.zeige__wgruppe.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 4028 ) 4029 WHERE 4030 -- 4031 -- nur die gültigen Abkürzungen zeigen 4032 -- 4033 prj.zeige__psabk.ps__abk__id > 0 4034 AND 4035 -- 4036 -- Projekt auswählen 4037 -- 4038 prj.zeige__psabk.prj__p_psabk__prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 4039 ORDER BY 4040 prj.zeige__psabk.ps__abk__typ 4041 , abkuerzung 4042 ; 4043 """ 4044 , permDaten = self.daten__psAbk__Projekt__Sprache 4045 , istDict = True ) 4046 4047 4048 # 4049 # -- dem >wxObjekt< die Werte der globalen Variable übergeben ---------- 4050 # 4051 if( ComboBoxErg_ListBoxSpWTitelAL is None ) : return 4052 if( psAbkTyp is None ) : return 4053 4054 4055 4056 # 4057 # -- >ComboBoxErg< oder >ListBoxSpWTitelAL< ---------------------------------- 4058 # 4059 istComboBoxErg = not ( str( ComboBoxErg_ListBoxSpWTitelAL ).find( "ListBoxSpWTitelAL" ) >= 0 ) 4060 if( ComboBoxErg_ListBoxSpWTitelAL is None ) : istComboBoxErg = None 4061 4062 4063 4064 # 4065 # -- Eingabefelder zurücksetzen ------------------------------------------ 4066 # 4067 if( istComboBoxErg ) : 4068 4069 ComboBoxErg_ListBoxSpWTitelAL.loescheAlles() 4070 4071 else : 4072 4073 ComboBoxErg_ListBoxSpWTitelAL.ListBox__li.loescheAlles() 4074 ComboBoxErg_ListBoxSpWTitelAL.ListBox__re.loescheAlles() 4075 4076 4077 # 4078 # -- es sind keine Abkürzungen darzustellen ---------------------------------- 4079 # 4080 if( len( self.daten__psAbk__Projekt__Sprache ) == 0 ) : return 4081 4082 4083 4084 # 4085 # -- Dem gewählten Typ sind keine Werte zugeordnet -------------------------- 4086 # 4087 if( psAbkTyp not in self.daten__psAbk__Projekt__Sprache ) : 4088 4089 return 4090 4091 4092 4093 # 4094 # -- Abkürzungen übernehmen ---------------------------------- 4095 # 4096 for i in range( len( self.daten__psAbk__Projekt__Sprache[psAbkTyp] ) ): 4097 4098 if( istComboBoxErg ) : 4099 4100 ComboBoxErg_ListBoxSpWTitelAL.nimmWert( wert = self.daten__psAbk__Projekt__Sprache[psAbkTyp][i][0] 4101 , clientData = [ # -- ps.abk.id ----------- 4102 self.daten__psAbk__Projekt__Sprache[psAbkTyp][i][1]] ) 4103 else : 4104 4105 ComboBoxErg_ListBoxSpWTitelAL.ListBox__re.nimmWert( 4106 wert = self.daten__psAbk__Projekt__Sprache[psAbkTyp][i][0] 4107 , clientData = [ # -- ps.abk.id ----------- 4108 self.daten__psAbk__Projekt__Sprache[psAbkTyp][i][1]] )

4109 4110 4111 4112 4113 # 4114 # ------------------------------------------------------------------------------------ 4115 # ------------------------------------------------------------------------------------ 4116 # -- >self.daten__psAbk_Risikomatrix< initialisieren ------------------ 4117 # ------------------------------------------------------------------------------------ 4118 # ------------------------------------------------------------------------------------ 4119 #

4120 - def init__psAbk_Risikomatrix( self ):

4121 """ 4122 Es wird die Permanente Datenstruktur C{self.daten__psAbk_Risikomatrix} initialisiert. 4123 """ 4124 4125 # 4126 # -- SQL-Abfrage ausführen, Protokolldatei schreiben ------------------ 4127 # -- und ggf. globale Variable aktualisieren ------------------ 4128 # 4129 self.__initPermDatenstruktur__( protokollDatKopf = "init__psAbk_Risikomatrix()" 4130 , sql = """ 4131 SELECT DISTINCT 4132 CAST( ps__abk__id_hfg as varchar ) || '-' || CAST( ps__abk__id_gstufe as varchar ) AS hfggef 4133 , ps__abk__id_rstufe 4134 FROM 4135 ps.zeige__risikomatrix_en50126 4136 ORDER BY 4137 hfggef 4138 """ 4139 , permDaten = self.daten__psAbk_Risikomatrix 4140 , istDict = True )

4141 4142 4143 4144 4145 4146 4147 # 4148 # ------------------------------------------------------------------------------------ 4149 # ------------------------------------------------------------------------------------ 4150 # -- wxComboBox der Tabelle 'spr.sprachen' initialisieren ------------------ 4151 # ------------------------------------------------------------------------------------ 4152 # ------------------------------------------------------------------------------------ 4153 #

4154 - def init__sprSprachen( self, wxComboBox ):

4155 """ 4156 Methode zur Initialisierung der Auswahlliste (C{wxComboBox}), welche die in der Datenbank verfügbaren Sprachen aufnimmt (darstellt). 4157 Sie wird nicht im Rahmen der Bearbeitung der Risikoanalyse, des Gefahrenprotokolls oder des Terminplans vom Benutzer verändert. 4158 4159 @note: Die übergebene Auswahlliste (C{wxComboBox}) wird verändert ! 4160 4161 @param wxComboBox: Es ist die Auswahlliste zu übergeben, die die Sprachen aufnimmt. Sie darf C{None} sein. In diesem Fall wird C{self.daten__sprSprachen} aktualisiert (wenn es selber C{None} ist). 4162 @type wxComboBox: wxPython - ComboBox 4163 """ 4164 4165 # 4166 # -- die globale Variable muß mit Werten gefüllt werden ------------------ 4167 # -- (Datenbankabfrage durchführen) ------------------ 4168 # 4169 self.__initPermDatenstruktur__( protokollDatKopf = "init__sprSprachen()" 4170 , sql = """ 4171 SELECT 4172 sprache 4173 , id 4174 FROM 4175 spr.sprachen 4176 WHERE 4177 spr.sprachen.idfrei = 0 4178 AND 4179 id > 0 4180 ORDER BY 4181 sprache 4182 ;""" 4183 , permDaten = self.daten__sprSprachen ) 4184 4185 4186 4187 4188 # 4189 # -- dem >wxObjekt< die Werte der globalen Variable übergeben ---------- 4190 # 4191 self.init__WxControlWithItemsPerm( permDaten = self.daten__sprSprachen 4192 , wxObjekt = wxComboBox )

4193 4194 4195 4196 # 4197 # ------------------------------------------------------------------------------------ 4198 # ------------------------------------------------------------------------------------ 4199 # -- wxListBox der Tabelle 'str.name' initialisieren ------------------ 4200 # ------------------------------------------------------------------------------------ 4201 # ------------------------------------------------------------------------------------ 4202 #

4203 - def init__strName( self ):

4204 """ 4205 Es wird die Permanente Datenstruktur C{self.daten__strName} initialisiert. 4206 """ 4207 4208 # 4209 # -- die globale Variable muß mit Werten gefüllt werden ------------------ 4210 # -- (Datenbankabfrage durchführen) ------------------ 4211 # 4212 self.__initPermDatenstruktur__( protokollDatKopf = "init__strName()" 4213 , sql = """ 4214 SELECT 4215 name_k || ' | ' || name 4216 , id 4217 FROM 4218 str.name 4219 WHERE 4220 idfrei = 0 4221 AND 4222 id > 0 4223 AND 4224 id <> 2 4225 ORDER BY 4226 name_k 4227 ;""" 4228 , permDaten = self.daten__strName )

4229 4230 4231 4232 4233 # 4234 # ------------------------------------------------------------------------------------ 4235 # ------------------------------------------------------------------------------------ 4236 # -- Permanente Datenstruktur der Dokumente initialisieren ------------------ 4237 # ------------------------------------------------------------------------------------ 4238 # ------------------------------------------------------------------------------------ 4239 #

4240 - def init__strStrkt__Projekt__Sprache( self ):

4241 """ 4242 Es wird die Permanente Datenstruktur C{self.daten__strStrkt__Projekt__Sprache} initialisiert. 4243 """ 4244 4245 # 4246 # -- SQL-Abfrage ausführen und Protokolldatei schreiben ------------------ 4247 # -- ggf. permanente Datenstruktur aktualisieren ------------------ 4248 # 4249 self.__initPermDatenstruktur__( protokollDatKopf = "init_strStrkt_Projekt()" 4250 , sql = """ 4251 SELECT DISTINCT 4252 -- 0 4253 prj.zeige__strstrkt.str__strkt__nr || ' ' || COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS strpkt 4254 , prj.zeige__strstrkt.str__strkt__id 4255 -- 2 4256 , nachfok.str__strkt__id AS str_strkt_id__vorg 4257 , prj.zeige__strstrkt.str__name__name_k 4258 -- 4 4259 , prj.zeige__strstrkt.str__name__id 4260 FROM 4261 prj.zeige__strstrkt 4262 -- 4263 -- Strukturpunkt 4264 -- 4265 LEFT OUTER JOIN spr.zeige__wgruppe 4266 ON ( 4267 prj.zeige__strstrkt.prj__pp_strstrkt__spr_uebvar_id = 4268 spr.zeige__wgruppe.spr_uebvar_id 4269 AND 4270 -- 4271 -- Sprache Auswählen 4272 -- 4273 spr.zeige__wgruppe.spr_sprachen_id = """ 4274 + str( self.filter__spr_sprachen_id ) + """ 4275 ) 4276 -- 4277 -- aktueller Strukturpunkt ist ein gültiger Nachfolger 4278 -- 4279 LEFT OUTER JOIN prj.zeige__strstrkt AS nachfok 4280 ON ( 4281 nachfok.prj__p_strverbindung__str_strkt_id_nachf = prj.zeige__strstrkt.str__strkt__id 4282 AND 4283 nachfok.prj_projekte_id = prj.zeige__strstrkt.prj_projekte_id 4284 ) 4285 WHERE 4286 -- 4287 -- Projekt auswählen 4288 -- 4289 prj.zeige__strstrkt.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 4290 ORDER BY 4291 prj.zeige__strstrkt.str__name__id 4292 , strpkt 4293 ;""" 4294 , permDaten = self.daten__strStrkt__Projekt__Sprache )

4295 4296 4297 4298 4299 # 4300 # ------------------------------------------------------------------------------------ 4301 # ------------------------------------------------------------------------------------ 4302 # -- wxControlWithItems initialisieren unter Berücksichtigung der ---------- 4303 # -- globalen Variablen (Zugriffszeiten reduzieren) ---------- 4304 # ------------------------------------------------------------------------------------ 4305 # ------------------------------------------------------------------------------------ 4306 #

4307 - def init__WxControlWithItemsPerm( self, permDaten, wxObjekt, eintragNull = [], filter = None, formatiereWert = 0 ):

4308 """ 4309 Interne Methode zur Initialisierung eines C{wx-Objektes} mit den Daten der permanenten Datenstruktur C{permDaten}, welches eine Listenform hat. 4310 4311 @note: C{permDaten} und das übergebene C{wx-Objekt} wird verändert ! 4312 4313 @param permDaten: Es ist die globale Variable zu übergeben, die die darzustellenden Werte enthält. 4314 @type permDaten: Liste 4315 4316 @param wxObjekt: Es ist das C{wx-Objekt} zu übergeben, welches Datenbankwerte aufnimmt (darstellt). Es darf C{None} sein. In diesem Fall wird C{permDaten} aktualisiert (wenn es selber C{None} ist). 4317 @type wxObjekt: C{wx-Objekt} 4318 4319 @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 4320 @type eintragNull: Liste 4321 4322 @param filter: Es kann ein Wert angegeben werden, nach dem die zu übernehmenden Daten in C{permDaten} gefiltert wrden. 4323 @type filter: beliebiger Wert 4324 4325 @param formatiereWert: Es ist der Formatierungsparameter für den im C{wx-Objekt} dargestellten Wert zu übergeben. Es bedeuten C{0 ... keine Formatierung}, C{1 ... Zahlenwert: Führende Nullen bei vierstelligen Werten} 4326 @type formatiereWert: C{wx-Objekt} 4327 """ 4328 4329 # 4330 # -------------------------------------------------------------------------------- 4331 # -- dem >wxObjekt< die Werte der globalen Variable übergeben ---------- 4332 # -------------------------------------------------------------------------------- 4333 # 4334 if( wxObjekt is None ) : return 4335 wxObjekt.loescheAlles() 4336 4337 # 4338 # -- Nulleintrag vorhanden -------------------------------------------------- 4339 # 4340 if( len( eintragNull ) == 2 ) : 4341 4342 wxObjekt.nimmWert( wert = str( eintragNull[0] ), clientData = eintragNull[1] ) 4343 4344 4345 # 4346 # -- Werte übernehmen -------------------------------------------------- 4347 # 4348 for i in range( len( permDaten ) ): 4349 4350 # 4351 # -- Erste Formatierungsvariante ---------------------------------- 4352 # 4353 tmp = permDaten[i][0] 4354 4355 if( formatiereWert == 1 ) : 4356 4357 tmp = zk.gibIdWertNotizen( id = tmp, zusInfo = "" ) 4358 4359 4360 # 4361 # -- Filter ist aktiv ------------------------------------------ 4362 # 4363 if( filter is not None ) : 4364 4365 if( permDaten[i][len( permDaten[i] ) - 1] != filter ) : 4366 4367 continue 4368 4369 wxObjekt.nimmWert( wert = str( permDaten[i][0] ), clientData = permDaten[i][1:len( permDaten[i] ) - 1] ) 4370 4371 4372 # 4373 # -- Filter ist nicht aktiv ------------------------------------------ 4374 # 4375 else : 4376 4377 wxObjekt.nimmWert( wert = str( permDaten[i][0] ), clientData = permDaten[i][1:len( permDaten[i] )] ) 4378 4379 4380 4381 # 4382 # -- ersten Eintrag selektieren ------------------------------------------ 4383 # 4384 wxObjekt.selektiereWert( clientDataId = 0 )

4385 4386 4387 4388 4389 # 4390 # ------------------------------------------------------------------------------------ 4391 # ------------------------------------------------------------------------------------ 4392 # -- ------------------ 4393 # ------------------------------------------------------------------------------------ 4394 # ------------------------------------------------------------------------------------ 4395 #

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

4397 """ 4398 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. 4399 4400 @param zielSpalte: Es ist der vollständige Datenbankspaltenname anzugeben, auf den mittels Fremdschlüssel verwiesen wird. 4401 @type zielSpalte: Zeichenkette 4402 4403 @param dbId: Es ist die Datenbankidentifikationsnummer anzugeben, die überprüft werden soll. 4404 @type dbId: Ganzzahl 4405 4406 @return: Es wird C{True} zurückgegeben, wenn C{dbId} in mindestens zwei Tabellen verwendet wird. 4407 @rtype: Ganzzahl 4408 """ 4409 4410 # 4411 # -- Liste der Tabellenverbindungen auswählen -------------------------- 4412 # 4413 liste = None 4414 4415 if( zielSpalte == 'spr.uebvar.id' ) : liste = self.listeTabellenSprUebvarId 4416 4417 if( liste is None ) : return False 4418 4419 4420 4421 4422 # 4423 # -- in Protokolldatei schreiben ------------------------------------------ 4424 # 4425 self.ProtokolldateiEintragen( eintrag = "istIdMehrfachVerwendet()" 4426 , istKopfzeile = True ) 4427 4428 4429 4430 # 4431 # -- alle Tabellen durchlaufen, die auf >zielSpalte< referenzieren ---------- 4432 # 4433 anzVerwendet = 0 4434 for i in range( len( liste ) ) : 4435 4436 self.__dbAbfrage__( """ 4437 -- 4438 -- Anzahl der Zeilen in der akt. Tabelle zählen, die >dbId< verwenden 4439 -- 4440 SELECT 4441 count( """ + liste[i][1] + """ ) 4442 FROM 4443 """ + liste[i][0] + """ 4444 WHERE 4445 idfrei = 0 4446 AND 4447 """ + liste[i][1] + """ = """ + str( dbId ) + """ 4448 ;""" ) 4449 4450 anzVerwendet += self.__gibWert__( 0, 0 ) 4451 4452 if( anzVerwendet > 1 ) : return True 4453 4454 4455 4456 # 4457 # -- >dbId< wurde nicht mehrfach verwendet ---------------------------------- 4458 # 4459 return False

4460 4461 4462 4463 # 4464 # ------------------------------------------------------------------------------------ 4465 # ------------------------------------------------------------------------------------ 4466 # -- Änderungen übernehmen (aktuelle Transaktion schließen, ------------------ 4467 # -- neue Transaktion starten) ------------------ 4468 # ------------------------------------------------------------------------------------ 4469 # ------------------------------------------------------------------------------------ 4470 #

4471 - def nimmAenderungen( self ):

4472 """ 4473 Es werden alle Änderungen in die Datenbank geschrieben, die laufende Transaktion beendet und eine neue Transaktion gestartet. 4474 """ 4475 4476 # 4477 # -- Änderungen übernehmen, Transaktion starten -------------------------- 4478 # 4479 self.dbVerbindung.commit()

4480 4481 4482 4483 4484 4485 # 4486 # ------------------------------------------------------------------------------------ 4487 # ------------------------------------------------------------------------------------ 4488 # -- Alle Änderungen seit Setzen eines PostgreSQL-Safepoints übernehmen -- 4489 # ------------------------------------------------------------------------------------ 4490 # ------------------------------------------------------------------------------------ 4491 #

4492 - def nimmAenderungenSafepoint( self, name ):

4493 """ 4494 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. 4495 4496 @param name: Es ist der Name des C{Safepoints} anzugeben. 4497 @type name: Zeichenkette 4498 """ 4499 4500 # 4501 # -- in Protokolldatei schreiben ------------------------------------------ 4502 # 4503 self.ProtokolldateiEintragen( eintrag = "nimmAenderungenSafepoint()" 4504 , istKopfzeile = True ) 4505 4506 4507 4508 4509 # 4510 # -- Änderungen übernehmen -------------------------------------------------- 4511 # 4512 self.__dbAbfrage__( 'RELEASE SAVEPOINT ' + name + ';' )

4513 4514 4515 4516 # 4517 # ------------------------------------------------------------------------------------ 4518 # ------------------------------------------------------------------------------------ 4519 # -- Gefahrenszenario-Id übernehmen ------------------------------------------ 4520 # ------------------------------------------------------------------------------------ 4521 # ------------------------------------------------------------------------------------ 4522 #

4523 - def nimm__PsGefszenarioId( self, wxListBox ) :

4524 """ 4525 Methode, die die aktuell gewählte C{ps.gefszenario.id} übernimmt. 4526 4527 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Gefahrenszenario-Id enthält. 4528 @type wxListBox: wxPython - ListBox 4529 """ 4530 4531 # 4532 # -- Gefahrenszenario-Id übernehmen ------------------------------------------ 4533 # 4534 self.ps_gefszenario_id = None 4535 4536 if( len( wxListBox.GetStringSelection() ) > 0 ) : 4537 4538 self.ps_gefszenario_id = int( wxListBox.GetStringSelection() )

4539 4540 4541 4542 4543 # 4544 # ------------------------------------------------------------------------------------ 4545 # ------------------------------------------------------------------------------------ 4546 # -- Zeilen ind die Protokolldatei eintragen -------------------------- 4547 # ------------------------------------------------------------------------------------ 4548 # ------------------------------------------------------------------------------------ 4549 #

4550 - def ProtokolldateiEintragen( self, eintrag = "", istKopfzeile = False ) :

4551 """Es wird ein Eintrag in die Protokolldatei geschrieben. 4552 4553 @param eintrag: Es ist der Eintrag anzugeben. 4554 @type eintrag: Zeichenkette 4555 4556 @param istKopfzeile: Es ist die C{True} anzugeben, wenn der Eintrag eine Kopfzeile ist. 4557 @type istKopfzeile: Boolean 4558 """ 4559 4560 4561 # 4562 # -- Eintrag in der Protokolldatei ------------------------------------------ 4563 # 4564 self.__ProtokolldateiEintrag__ = eintrag 4565 4566 4567 # 4568 # -- Protokolldatei wird nicht geschrieben ---------------------------------- 4569 # 4570 if( self.Protokolldatei is None ) : 4571 4572 return 4573 4574 4575 # 4576 # -- Eintrag schreiben -------------------------------------------------- 4577 # 4578 if( istKopfzeile ) : 4579 4580 self.Protokolldatei.debug( '\n\n--\n--\n-- -----\t' + eintrag + '\t---------------------------------------------\n--\n--\n' ) 4581 4582 else : 4583 4584 self.Protokolldatei.debug( eintrag + '\n' )

4585 4586 4587 4588 4589 # 4590 # ------------------------------------------------------------------------------------ 4591 # ------------------------------------------------------------------------------------ 4592 # -- Die Protokolldatei erzeugen ------------------------------------------ 4593 # ------------------------------------------------------------------------------------ 4594 # ------------------------------------------------------------------------------------ 4595 #

4596 - def ProtokolldateiErzeugen( self, schreibProtokollDatei = False ) :

4597 """Es wird die Protokolldatei angelegt. 4598 4599 @param schreibProtokollDatei: Es ist die C{True} anzugeben, wenn die Protokolldatei geschrieben werden soll. 4600 @type schreibProtokollDatei: Boolean 4601 """ 4602 4603 # 4604 # -- Protokolldatei soll angelegt werden ---------------------------------- 4605 # 4606 if( schreibProtokollDatei ) : 4607 4608 self.Protokolldatei = logging.getLogger( 'Protokolldatei' ) 4609 self.Protokolldatei.setLevel( logging.DEBUG ) 4610 4611 handler = logging.handlers.RotatingFileHandler( 'wxvf.log', maxBytes=1000000, backupCount=5 ) 4612 self.Protokolldatei.addHandler( handler ) 4613 4614 self.ProtokolldateiEintragen( eintrag = ">wxvf< wird ausgeführt:" 4615 , istKopfzeile = True )

4616 4617 4618 4619 4620 # 4621 # ------------------------------------------------------------------------------------ 4622 # ------------------------------------------------------------------------------------ 4623 # -- Schreibe Tabellen: -------------------------------------------------- 4624 # -- >dok.doku< -------------------------------------------------- 4625 # ------------------------------------------------------------------------------------ 4626 # ------------------------------------------------------------------------------------ 4627 #

4628 - def schreibe__DokDoku( self, listeWerte, listeDokDokuId, entferneDokDokuId = None ):

4629 """ 4630 Es werden Dokumente neu angelegt, aktualisiert bzw. entfernt. Datenbankabhängigkeiten werden berücksichtigt. 4631 Wenn C{dok.doku.id} leer ist, wird ein neues Dokument angelegt. 4632 4633 @param listeWerte: Es sind C{[dok.doku.id, dok.doku.notizen, dok.doku.intern_firma_id, dok.doku.spr_uebvar_id_kb, dok.doku.aspekt]} zu übergeben. Wenn ein Dokument entfernt wrden soll, darf C{None} übergeben werden 4634 @type listeWerte: Python Liste 4635 4636 @param listeDokDokuId: Es sind C{dok.doku.id} aller in der Datenbank vorhandenen Dokumente zu übergeben. Wenn ein Dokument entfernt wrden soll, darf C{None} übergeben werden 4637 @type listeWerte: Python Liste 4638 4639 @param entferneDokDokuId: Es ist die C{dok.doku.id} des Dokumentes anzugeben, welches entfernt werden soll. 4640 @type entferneDokDokuId: Ganzzahl 4641 4642 @return: Es wird die C{dok.doku.id} des neu eingelesenen / bearbeiteten Dokumentes zurückgegeben. Wenn das Dokument bereits vorhanden ist, wird C{None} angegeben. 4643 @rtype: Ganzzahl 4644 """ 4645 4646 # 4647 # -- in Protokolldatei schreiben ------------------------------------------ 4648 # 4649 self.ProtokolldateiEintragen( eintrag = "schreibe__DokDoku()" 4650 , istKopfzeile = True ) 4651 4652 4653 4654 4655 # 4656 # -- 4657 # -- Layout der Werteliste -------------------------------------------------- 4658 # -- >dok.doku< ---------- 4659 # -- ---------- 4660 # -- ---------- 4661 # -- dok.doku.id listeWerte[0] ---------- 4662 # -- dok.doku.notizen listeWerte[1] ---------- 4663 # -- dok.doku.intern_firma_id listeWerte[2] ---------- 4664 # -- dok.doku.spr_uebvar_id_kb listeWerte[3] ---------- 4665 # -- dok.doku.aspekt listeWerte[4] ---------- 4666 # 4667 if( listeWerte is not None ) : 4668 4669 dokDokuId = listeWerte[0] 4670 4671 4672 4673 # 4674 # -- 4675 # -- Dokument entfernen -------------------------------------------------- 4676 # -- >dok.doku< ---------------------------------- 4677 # -- ---------------------------------- 4678 # -- ------------------ 4679 # -- Konzept: ------------------ 4680 # -- 1. Prüfen, ob es in den Projekten verwendet wird ------------------ 4681 # -- 2. Wenn es nicht verwendet wird, dann löschen ------------------ 4682 # -- ------------------ 4683 # -- ------------------ 4684 # -- -------------------------------------------------------------------------- 4685 # 4686 if( entferneDokDokuId is not None ) : 4687 4688 # 4689 # -- Dokument wird verwendet -> nicht entfernen ------------------ 4690 # 4691 if( self.finde__dokDokuId( dokDokuId = entferneDokDokuId, ignorierePrjProjekteId = True ) ) : 4692 4693 return None 4694 4695 4696 4697 # 4698 # -- Dokument entfernen ------------------------------------------ 4699 # 4700 self.__dbAbfrage__( """ 4701 SELECT intern.loesche__zeile( 'dok.doku' 4702 , 'dok.doku.id = """ + str( entferneDokDokuId ) + """' 4703 , 'true');""" ) 4704 4705 4706 # 4707 # -- Dokument wurde entfernt ------------------------------------------ 4708 # 4709 return entferneDokDokuId 4710 4711 4712 4713 # 4714 # -- 4715 # -- Neues Dokument anlegen ------------------------------------------ 4716 # -- >dok.doku< ---------------------------------- 4717 # -- ---------------------------------- 4718 # -- ---------------------------------- 4719 # -- dok.nimm__doku( 1. spr_uebvar_id_kb ---------------------------------- 4720 # -- 2. intern_firma_id ---------------------------------- 4721 # -- ---------------------------------- 4722 # -- ---------------------------------- 4723 # -- Konzept: ---------------------------------- 4724 # -- Es wird in zwei Schritten eingelesen: ---------------------------------- 4725 # -- 1. Dopplungen vermeiden ---------------------------------- 4726 # -- 2. Aspekt, Notizen einlesen ---------------------------------- 4727 # -- ---------------------------------- 4728 # -- ---------------------------------- 4729 # -- -------------------------------------------------------------------------- 4730 # 4731 if( len( dokDokuId ) == 0 ) : 4732 4733 self.__dbAbfrage__( """ 4734 SELECT dok.nimm__doku( ARRAY[""" 4735 # 4736 # -- spr_uebvar_id_kb ---------------------------------- 4737 # 4738 + "'" + str( listeWerte[3] ) + "'" 4739 # 4740 # -- intern_firma_id ------------------------------------------ 4741 # 4742 + ", '" + str( listeWerte[2] ) + "']);" ) 4743 4744 dokDokuId = self.__gibWert__( 0, 0 ) 4745 4746 if( int( dokDokuId ) in listeDokDokuId ) : 4747 4748 return None 4749 4750 4751 4752 # 4753 # -- 4754 # -- Dokument bearbeiten (einschl. aspekt, notizen einlesen) ------------------ 4755 # -- bei Anlegen eines neuen Dokumentes ------------------ 4756 # -- >dok.doku< ------------------ 4757 # -- ------------------ 4758 # -- ------------------ 4759 # -- intern.nimm__zeile( 'dok.doku', ARRAY[ ------------------ 4760 # -- 'id' ------------------ 4761 # -- , 'notizen' ------------------ 4762 # -- , 'intern_firma_id' ------------------ 4763 # -- , 'spr_uebvar_id_kb' ------------------ 4764 # -- , 'aspekt' ------------------ 4765 # -- ], ARRAY[...] ) ------------------ 4766 # -- ------------------ 4767 # -- ------------------ 4768 # -- -------------------------------------------------------------------------- 4769 # 4770 self.__dbAbfrage__( """ 4771 SELECT intern.nimm__zeile( 'dok.doku', ARRAY[ 4772 'id' 4773 , 'notizen' 4774 , 'intern_firma_id' 4775 , 'spr_uebvar_id_kb' 4776 , 'aspekt' 4777 ], ARRAY['""" 4778 # 4779 # -- id ------------------------------------------ 4780 # 4781 + str( dokDokuId ) + "'" 4782 # 4783 # -- notizen ------------------------------------------ 4784 # 4785 + ", '" + listeWerte[1].encode('utf-8') + "'" 4786 # 4787 # -- intern_firma_id ---------------------------------- 4788 # 4789 + ", '" + str( listeWerte[2] ) + "'" 4790 # 4791 # -- spr_uebvar_id_kb ---------------------------------- 4792 # 4793 + ", '" + str( listeWerte[3] ) + "'" 4794 # 4795 # -- aspekt -------------------------------------------------- 4796 # 4797 + ", '" + listeWerte[4] + "']);" ) 4798 4799 4800 # 4801 # -- aktuelle >dok.doku.id< zurückgeben ---------------------------------- 4802 # 4803 return dokDokuId

4804 4805 4806 4807 # 4808 # ------------------------------------------------------------------------------------ 4809 # ------------------------------------------------------------------------------------ 4810 # -- Protokolleintrag mittels UPDATE aktualisieren -------------------------- 4811 # ------------------------------------------------------------------------------------ 4812 # ------------------------------------------------------------------------------------ 4813 #

4814 - def schreibe__DokDoku__UPDATE( self, dokDokuId, sprUebvarIdKb, Notizen ):

4815 """ 4816 Methode zum Aktualisieren eines Dokumentes in C{dok.doku} mittels C{UPDATE}. 4817 4818 @param DokDokuId: Es ist die C{dok.doku.id} des Dokumentes anzugeben. 4819 @type DokDokuId: Ganzzahl 4820 4821 @param sprUebvarIdKb: Es ist die C{dok.doku.spr_uebvar_id_kb} anzugeben. 4822 @type sprUebvarIdKb: Ganzzahl 4823 4824 @param Notizen: Es ist C{dok.doku.notizen} anzugeben. 4825 @type Notizen: Zeichenkette 4826 """ 4827 4828 # 4829 # -- in Protokolldatei schreiben ------------------------------------------ 4830 # 4831 self.ProtokolldateiEintragen( eintrag = "schreibe__DokDoku__UPDATE()" 4832 , istKopfzeile = True ) 4833 4834 4835 4836 4837 # 4838 # -- Datenbank aktualisieren ------------------------------------------ 4839 # 4840 self.__dbAbfrage__( """ 4841 UPDATE 4842 dok.doku 4843 SET 4844 spr_uebvar_id_kb = """ + str( sprUebvarIdKb ) + """ 4845 , notizen = '""" + Notizen.encode('utf-8') + """' 4846 WHERE 4847 id = """ + str( dokDokuId ) + """;""" )

4848 4849 4850 4851 4852 4853 4854 # 4855 # ------------------------------------------------------------------------------------ 4856 # ------------------------------------------------------------------------------------ 4857 # -- Schreibe Tabellen: ---------- 4858 # -- >prj.ppl_dokdoku<, >prj.pl_prtdokdoku<, >prj.pl_dokausgabe< ---------- 4859 # ------------------------------------------------------------------------------------ 4860 # ------------------------------------------------------------------------------------ 4861 #

4862 - def schreibe__Dokumente( self, TreeCtrlErg, nimmAusgabe = False, ignorierePsGefszenarioId = False ):

4863 """ 4864 Übernehmen der Strukturpunkte, die den im C{TreeCtrlErg} selektierten Sicherheitsanforderungen C{prt.protokoll.id} zugeordnet sind, in das Projekt C{prjProjekteId}. 4865 4866 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die selektierten Sicherheitsanforderungen enthält. 4867 @type TreeCtrlErg: TreeCtrlErg 4868 4869 @param nimmAusgabe: Es ist C{True} anzugeben, wenn die Ausgabe zum Dokument übernommen werden soll. 4870 @type nimmAusgabe: Boolean 4871 4872 @param ignorierePsGefszenarioId: Es ist die C{True} anzugeben, wenn C{self.ps_gefszenario_id} in der SQL-Abfrage berücksichtigt werden soll. 4873 @type ignorierePsGefszenarioId: Boolean 4874 """ 4875 4876 # 4877 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 4878 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 4879 # 4880 if( self.ps_gefszenario_id is None 4881 and not ignorierePsGefszenarioId ) : 4882 4883 return 4884 4885 4886 4887 # 4888 # -- in Protokolldatei schreiben ------------------------------------------ 4889 # 4890 self.ProtokolldateiEintragen( eintrag = "schreibe__Dokumente()" 4891 , istKopfzeile = True ) 4892 4893 4894 4895 4896 # 4897 # -- Gefahrenszenario-Id ignorieren ---------------------------------- 4898 # 4899 psGefszenarioId = self.ps_gefszenario_id 4900 if( ignorierePsGefszenarioId ) : psGefszenarioId = None 4901 4902 4903 4904 # 4905 # -- alle Sicherheitsanforderungen-Id zusammenstellen -------------------------- 4906 # 4907 eintragListe = TreeCtrlErg.gibZweig() 4908 prtProtokollIdListe = "" 4909 4910 for i in range( len( eintragListe ) ) : 4911 4912 if( i > 0 ) : prtProtokollIdListe = prtProtokollIdListe + ', ' 4913 prtProtokollIdListe = prtProtokollIdListe + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) 4914 4915 4916 4917 # 4918 # -- Wenn Dokument von der Sicherheitsanforderung gelöst wird: ---------- 4919 # -- Sicherheitsanforderungen in Liste der nichtzutrennenden ---------- 4920 # -- SiAnf-Id aufnehmen ---------- 4921 # 4922 logentfernt = False 4923 nichtTrennen = [] 4924 4925 if( psGefszenarioId is not None ) : 4926 4927 logentfernt = True 4928 4929 self.__dbAbfrage__( self.__gibSQLSelect__( 4930 select = """ 4931 SELECT DISTINCT 4932 prt_protokoll_id""" 4933 , tabellen = [ self.__gibSQLSelect__PlPrtPsGefszenario__( sqlJOIN = None 4934 , sqlWHERE = """ 4935 AND 4936 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id IN( """ + str( prtProtokollIdListe ) + """ ) 4937 AND 4938 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id != """ + str( psGefszenarioId ) + """ 4939 AND 4940 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) ) ] ) ) 4941 4942 for i in range( self.__gibAnzZeilen__() ): 4943 4944 nichtTrennen.append( self.__gibWert__( i, 0 ) ) 4945 4946 4947 4948 # 4949 # -- zugeordnete Dokumente auslesen ------------------------------------------ 4950 # 4951 prjProjekteIdintern = None 4952 4953 if( logentfernt ) : prjProjekteIdintern = self.filter__prj_projekte_id 4954 4955 self.__dbAbfrage__( self.__gibSQL_prjPrtDoku__( prjProjekteId = prjProjekteIdintern 4956 , sprSprachenId = self.filter__spr_sprachen_id 4957 , prtProtokollId = prtProtokollIdListe 4958 , internFirmaId = None 4959 , dokDokuId = dokDokuId 4960 , ignorierePsGefszenarioId = True ) ) 4961 4962 4963 # 4964 # -- 4965 # -- >prj.pl_prtdokdoku< -------------------------------------------------- 4966 # -- 4967 # -- prj_projekte_id <- prjProjekteId ------------------ 4968 # -- logentfernt <- 'false' ------------------ 4969 # -- 4970 # -- dok_doku_id <- self.__gibWert__( i, 0 ) ------------------ 4971 # -- prt_protokoll_id <- self.__gibWert__( i, 13 ) ------------------ 4972 # -- 4973 # -- nr <- self.__gibWert__( i, 2 ) ------------------ 4974 # -- spr_uebvar_id <- self.__gibWert__( i, 10 ) ------------------ 4975 # -- spr_uebvar_id_zus <- self.__gibWert__( i, 11 ) ------------------ 4976 # -- notizen <- self.__gibWert__( i, 4 ) ------------------ 4977 # 4978 # -- 4979 # -- >prj.pl_dokausgabe< -------------------------------------------------- 4980 # -- 4981 # -- prj_projekte_id <- prjProjekteId ------------------ 4982 # -- logentfernt <- 'false' ------------------ 4983 # -- 4984 # -- dok_doku_id <- self.__gibWert__( i, 0 ) ------------------ 4985 # -- 4986 # -- stand <- self.__gibWert__( i, 5 ) ------------------ 4987 # -- datum <- self.__gibWert__( i, 6 ) ------------------ 4988 # -- istfrei <- self.__gibWert__( i, 12 ) ------------------ 4989 # -- notizen <- self.__gibWert__( i, 7 ) ------------------ 4990 # -- 4991 # 4992 werte = [] 4993 plPrtDokdoku = [] 4994 plDokAusgabe = [] 4995 for i in range( self.__gibAnzZeilen__() ): 4996 4997 werte.append( [ self.__gibWert__( i, 0 ) 4998 , self.__gibWert__( i, 13 ) ] ) 4999 5000 plPrtDokdoku.append( [ self.__gibWert__( i, 2 ) 5001 , self.__gibWert__( i, 10 ) 5002 , self.__gibWert__( i, 11 ) 5003 , self.__gibWert__( i, 4 ) ] ) 5004 5005 5006 if( not nimmAusgabe ) : continue 5007 5008 plDokAusgabe.append( [ self.__gibWert__( i, 5 ) 5009 , self.__gibWert__( i, 6 ) 5010 , self.__gibWert__( i, 12 ) 5011 , self.__gibWert__( i, 7 ) ] ) 5012 5013 5014 # 5015 # -- Dokumente übernehmen / trennen ------------------------------------------ 5016 # 5017 for i in range( len( werte ) ) : 5018 5019 if( werte[i][1] in nichtTrennen ) : continue 5020 5021 plDokAusgabeIntern = None 5022 5023 if( nimmAusgabe and len( plDokAusgabe[i][0] ) > 0 ) : plDokAusgabeIntern = plDokAusgabe[i] 5024 5025 self.schreibe__prjPrtDoku( prjProjekteId = self.filter__prj_projekte_id 5026 , prtProtokollId = werte[i][1] 5027 , dokDokuId = werte[i][0] 5028 , plPrtDokdoku = plPrtDokdoku[i] 5029 , plDokAusgabe = plDokAusgabeIntern 5030 , logentfernt = logentfernt )

5031 5032 5033 5034 # 5035 # ------------------------------------------------------------------------------------ 5036 # ------------------------------------------------------------------------------------ 5037 # -- In Tabelle >prj.pp_strstrkt< schreiben -------------------------- 5038 # ------------------------------------------------------------------------------------ 5039 # ------------------------------------------------------------------------------------ 5040 #

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

5042 """ 5043 Methode zum Einfügen / Aktualisieren projektspezifischer Informationen in die / der Datenbanktabelle C{prj.pp_strstrkt}. 5044 5045 @param prjProjekteId : Es ist die Projekt-Id C{prj.projekte.id} zu übergeben. 5046 @type prjProjekteId : C{Ganzzahl} 5047 5048 @param strStrktId : Es ist die Struktur-Id C{str.strkt.id} zu übergeben. 5049 @type strStrktId : C{Ganzzahl} 5050 5051 @param prjPersonenId : Es ist die Personen-Id C{prj.personen.id} zu übergeben. 5052 @type prjPersonenId : C{Ganzzahl} 5053 5054 @param sprUebvarId : Es ist die Id der Übersetzungsvariante C{spr.uebvar.id} zu übergeben. 5055 @type sprUebvarId : C{Ganzzahl} 5056 5057 @param fbereignis : Es ist das Fehlerbaumereignis zu übergeben 5058 @type fbereignis : C{Zeichenkette} 5059 5060 @param notizen : Es sind die Notizen zu übergeben. 5061 @type notizen : C{Zeichenkette} 5062 """ 5063 5064 # 5065 # -- in Protokolldatei schreiben ------------------------------------------ 5066 # 5067 self.ProtokolldateiEintragen( eintrag = "schreibe__PrjPpStrstrkt()" 5068 , istKopfzeile = True ) 5069 5070 5071 5072 # 5073 # -- 5074 # -- Strukturpunkte in das Projekt übernehmen -------------------------- 5075 # -- >prj.pp_strstrkt< ---------- 5076 # -- ---------- 5077 # -- ---------- 5078 # -- prj.nimm__tabwerte( 'pp_strstrkt', ARRAY[ ---------- 5079 # -- 1. prj_projekte_id ---------- 5080 # -- 2. str_strkt_id ---------- 5081 # -- 3. prj_personen_id ---------- 5082 # -- 5. spr_uebvar_id ---------- 5083 # -- 6. fbereignis ---------- 5084 # -- 8. notizen ---------- 5085 # -- ---------- 5086 # -- ---------- 5087 # -- -------------------------------------------------------------------------- 5088 # 5089 self.__dbAbfrage__( """ 5090 SELECT prj.nimm__tabwerte( 'pp_strstrkt', ARRAY[""" 5091 # 5092 # -- prj_projekte_id ---------------------------------- 5093 # 5094 + "'" + str( prjProjekteId ) + "'" 5095 # 5096 # -- str_strkt_id ------------------------------------------ 5097 # 5098 + ", '" + str( strStrktId ) + "'" 5099 # 5100 # -- prj_personen_id ---------------------------------- 5101 # 5102 + ", '" + str( prjPersonenId ) + "'" 5103 # 5104 # -- spr_uebvar_id ------------------------------------------ 5105 # 5106 + ", '" + str( sprUebvarId ) + "']);" )

5107 5108 5109 5110 5111 5112 # 5113 # ------------------------------------------------------------------------------------ 5114 # ------------------------------------------------------------------------------------ 5115 # -- Schreibe Tabellen: ---------- 5116 # -- >prj.pp_strstrkt<, >prj.p_strverbindung<, >prj.p_prtstrstrkt< ---------- 5117 # ------------------------------------------------------------------------------------ 5118 # ------------------------------------------------------------------------------------ 5119 #

5120 - def schreibe__Strukturpunkte( self, TreeCtrlErg, ignorierePsGefszenarioId = False ):

5121 """ 5122 Übernehmen der Strukturpunkte, die den im C{TreeCtrlErg} selektierten Sicherheitsanforderungen C{prt.protokoll.id} zugeordnet sind, in das Projekt C{prjProjekteId}. 5123 5124 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die selektierten Sicherheitsanforderungen enthält. 5125 @type TreeCtrlErg: TreeCtrlErg 5126 5127 @param ignorierePsGefszenarioId: Es ist die C{True} anzugeben, wenn C{self.ps_gefszenario_id} in der SQL-Abfrage berücksichtigt werden soll. 5128 @type ignorierePsGefszenarioId: Boolean 5129 """ 5130 5131 # 5132 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 5133 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 5134 # 5135 if( self.ps_gefszenario_id is None 5136 and not ignorierePsGefszenarioId ) : 5137 5138 return 5139 5140 5141 5142 5143 # 5144 # -- in Protokolldatei schreiben ------------------------------------------ 5145 # 5146 self.ProtokolldateiEintragen( eintrag = "schreibe__Strukturpunkte()" 5147 , istKopfzeile = True ) 5148 5149 5150 5151 # 5152 # -- Gefahrenszenario-Id ignorieren ---------------------------------- 5153 # 5154 psGefszenarioId = self.ps_gefszenario_id 5155 if( ignorierePsGefszenarioId ) : psGefszenarioId = None 5156 5157 5158 5159 # 5160 # -- Sicherheitsanforderung(en) entfernen ---------------------------------- 5161 # 5162 siAnfEntfernen = ( psGefszenarioId is not None ) 5163 5164 5165 5166 # 5167 # -- alle Sicherheitsanforderungen-Id zusammenstellen ------------------ 5168 # 5169 eintragListe = TreeCtrlErg.gibZweig() 5170 prtProtokollIdListe = "" 5171 5172 for i in range( len( eintragListe ) ) : 5173 5174 if( i > 0 ) : prtProtokollIdListe = prtProtokollIdListe + ', ' 5175 prtProtokollIdListe = prtProtokollIdListe + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) 5176 5177 5178 5179 # 5180 # -- Sicherheitsanforderung(en) übernehmen: ---------- 5181 # -- ---------- 5182 # -- Die den Sicherheitsanforderungen-Id zugeordneten Strukturpunkte ---------- 5183 # -- projektübergreifend ermitteln ---------- 5184 # -- ---------- 5185 # -- ---------- 5186 # -- Sicherheitsanforderung(en) entfernen: ---------- 5187 # -- ---------- 5188 # -- Die Strukturpunkte kennzeichnen, die einem weiteren ---------- 5189 # -- Gefahrenszenario zugeordnet sind. ---------- 5190 # -- Diese Strukturpunkte dürfen nicht aus dem Projekt entfernt ---------- 5191 # -- werden. ---------- 5192 # -- ---------- 5193 # -- ---------- 5194 # -- ACHTUNG ! ---------- 5195 # -- ---------- 5196 # -- Strukturzuordnungen zu Dokumenten mittels >prj.p_dokstrkt< ---------- 5197 # -- werden momentan mißachtet ! ---------- 5198 # -- Strukturzuordnungen zu Gefahrenszenarien mittels ---------- 5199 # -- >prj.pl_psgefstrkt< werden implizit über ---------- 5200 # -- >prj.zeige__strstrkt.str__name__id != 2< berücksichtigt. ---------- 5201 # 5202 select = """ 5203 SELECT DISTINCT 5204 -- 0 5205 prj.zeige__strstrkt.str__strkt__id 5206 , nachfok.str__strkt__id AS str_strkt_id__vorg 5207 -- 2 5208 , prj.zeige__prtprotokolltabellen.prt__protokoll__id 5209 , prj.zeige__strstrkt.prj__pp_strstrkt__prj_personen_id 5210 -- 4 5211 , prj.zeige__strstrkt.prj__pp_strstrkt__spr_uebvar_id""" 5212 5213 tabellen = [ 5214 self.__gibSQLSelect__StrStrkt__( 5215 sqlJOIN = """ 5216 -- 5217 -- aktueller Strukturpunkt ist ein gültiger Nachfolger 5218 -- 5219 LEFT OUTER JOIN prj.zeige__strstrkt AS nachfok ON ( 5220 nachfok.prj__p_strverbindung__str_strkt_id_nachf = 5221 prj.zeige__strstrkt.str__strkt__id 5222 AND 5223 nachfok.prj_projekte_id = prj.zeige__strstrkt.prj_projekte_id 5224 )""" 5225 , sqlWHERE = """ 5226 -- 5227 -- -- Gefahrennetz nicht anzeigen ---------------------------------- 5228 -- 5229 prj.zeige__strstrkt.str__name__id != 2""" ) 5230 , self.__gibSQLSelect__PrtProtokolltabellenStrStrkt__( 5231 sqlJOIN = None 5232 , sqlWHERE = """ 5233 AND 5234 -- 5235 -- -- Strukturpunkt zuordnen ------------------------------------------ 5236 -- 5237 prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__str_strkt_id = 5238 prj.zeige__strstrkt.str__strkt__id""" ) ] 5239 5240 sqlWHERE = """ 5241 AND 5242 -- 5243 -- -- Protokoll auswählen / zuordnen ---------------------------------- 5244 -- 5245 prj.zeige__prtprotokolltabellen.prt__protokoll__id IN( """ + str( prtProtokollIdListe ) + """ )""" 5246 5247 prjProjekteIdintern = self.filter__prj_projekte_id 5248 5249 5250 5251 # 5252 # -- Sicherheitsanforderung(en) entfernen ---------------------------------- 5253 # 5254 if( siAnfEntfernen ) : 5255 5256 select = select + ( """ 5257 , ( ( prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id = """ 5258 + str( psGefszenarioId ) 5259 + """ AND prj.zeige__prtprotokolltabellen.prt__protokoll__id NOT IN( """ 5260 + str( prtProtokollIdListe ) 5261 + """ ) ) OR ( prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id != """ 5262 + str( psGefszenarioId ) 5263 + """ ) ) AS nicht_entfernen""" ) 5264 5265 tabellen.append( self.__gibSQLSelect__PlPrtPsGefszenario__( sqlJOIN = None 5266 , sqlWHERE = """ 5267 AND 5268 -- 5269 -- -- Protokollpunkt zuordnen ------------------------------------------ 5270 -- 5271 prj.zeige__prtprotokolltabellen.prt__protokoll__id = 5272 prj.zeige__pl_prtpsgefszenario.prt_protokoll_id 5273 AND 5274 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 5275 ORDER BY 5276 nicht_entfernen""" ) ) 5277 5278 sqlWHERE = None 5279 5280 prjProjekteIdintern = 0 5281 5282 5283 5284 # 5285 # -- SQL-Abfrage ausführen -------------------------------------------------- 5286 # 5287 self.__dbAbfrage__( self.__gibSQLSelect__( select = select, tabellen = tabellen, sqlWHERE = sqlWHERE ) ) 5288 5289 5290 5291 # 5292 # -- str_strkt_id <- self.__gibWert__( i, 0 ) ------------------ 5293 # -- str_strkt_id_nachf <- self.__gibWert__( i, 0 ) ------------------ 5294 # -- str_strkt_id_vorg <- self.__gibWert__( i, 1 ) ------------------ 5295 # -- prt_protokoll_id <- self.__gibWert__( i, 2 ) ------------------ 5296 # -- prj_personen_id <- self.__gibWert__( i, 3 ) ------------------ 5297 # -- spr_uebvar_id <- self.__gibWert__( i, 4 ) ------------------ 5298 # -- ------------------ 5299 # -- nicht Entfernen <- self.__gibWert__( i, 5 ) ------------------ 5300 # 5301 werte = [] 5302 nichtEntfernen = [] 5303 5304 for i in range( self.__gibAnzZeilen__() ): 5305 5306 werte.append( [ self.__gibWert__( i, 0 ) 5307 , self.__gibWert__( i, 1 ) 5308 , self.__gibWert__( i, 2 ) 5309 , self.__gibWert__( i, 3 ) 5310 , self.__gibWert__( i, 4 ) ] ) 5311 5312 5313 # 5314 # -- Nur für Sicherheitsanforderung(en) entfernen: ---------- 5315 # -- ---------- 5316 # -- Alle hier eingetragenen Strukturpunkte werden in ---------- 5317 # -- weiteren Gefahrenszenarien bzw. weiteren Sicherheits- ---------- 5318 # -- anforderungen verwendet. ---------- 5319 # -- Sie durfen nicht aus dem Projekt entfernt werden ! ---------- 5320 # 5321 if( siAnfEntfernen and self.__gibWert__( i, 5 ) == True ) : 5322 5323 nichtEntfernen.append( werte[i][0] ) 5324 nichtEntfernen.append( werte[i][1] ) 5325 5326 5327 5328 # 5329 # -- Strukturpunkte ... ------------------------------------------ 5330 # 5331 for i in range( len( werte ) ) : 5332 5333 # 5334 # -- Nur für Sicherheitsanforderung(en) entfernen: ---------- 5335 # -- ---------- 5336 # -- Alle hier eingetragenen Strukturpunkte werden in ---------- 5337 # -- weiteren Gefahrenszenarien bzw. weiteren Sicherheits- ---------- 5338 # -- anforderungen verwendet. ---------- 5339 # -- Sie durfen nicht aus dem Projekt entfernt werden ! ---------- 5340 # 5341 if( werte[i][0] in nichtEntfernen ) : continue 5342 5343 5344 5345 # 5346 # -- 5347 # -- ... in das Projekt (auch Projekt '0') übernehmen ---------- 5348 # -- >prj.pp_strstrkt< ---------- 5349 # -- ---------- 5350 # 5351 self.schreibe__PrjPpStrstrkt( prjProjekteId = prjProjekteIdintern 5352 , strStrktId = werte[i][0] 5353 , prjPersonenId = werte[i][3] 5354 , sprUebvarId = werte[i][4] 5355 , fbereignis = "" 5356 , notizen = "" ) 5357 5358 # 5359 # -- Sicherheitsanforderung(en) entfernen: ------------------ 5360 # -- Strukturpunkte aus dem Projekt entfernen ------------------ 5361 # 5362 if( siAnfEntfernen ) : 5363 5364 self.__dbAbfrage__( """ 5365 SELECT intern.loesche__zeile( 'prj.pp_strstrkt' 5366 , 'prj_personen_id = """ + str( werte[i][3] ) + """ 5367 AND prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 5368 AND str_strkt_id = """ + str( werte[i][0] ) + """' 5369 , 'true');""" ) 5370 5371 5372 5373 # 5374 # -- ... miteinander verbinden, wenn Vorgänger existiert ---------- 5375 # -- >prj.p_strverbindung< ---------- 5376 # 5377 if( werte[i][1] != '' ): 5378 5379 self.schreibe__prjPStrverbindung( prjProjekteId = prjProjekteIdintern 5380 , strStrktIdVorg = werte[i][1] 5381 , strStrktIdNachf = werte[i][0] 5382 , fbtor = "" 5383 , notizen = "" ) 5384 5385 # 5386 # -- Sicherheitsanforderung(en) entfernen: ------------------ 5387 # -- Verbindung zwischen den Strukturpunkten aus ------------------ 5388 # -- dem Projekt entfernen ------------------ 5389 # 5390 if( siAnfEntfernen ) : 5391 5392 self.__dbAbfrage__( """ 5393 SELECT intern.loesche__zeile( 'prj.p_strverbindung' 5394 , 'prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 5395 AND str_strkt_id_nachf = """ + str( werte[i][0] ) + """ 5396 AND str_strkt_id_vorg = """ + str( werte[i][1] ) + """' 5397 , 'true');""" ) 5398 5399 5400 5401 # 5402 # -- ... mit den Protokolleinträgen verbinden ------------------ 5403 # -- >prj.p_prtstrstrkt< ------------------ 5404 # 5405 self.schreibe__psPrtStrkt( prjProjekteId = prjProjekteIdintern 5406 , prtProtokollId = werte[i][3] 5407 , strStrktId = werte[i][0] 5408 , notizen = '' ) 5409 5410 # 5411 # -- Sicherheitsanforderung(en) entfernen: ------------------ 5412 # -- Strukturpunkte von den Protokolleinträgen lösen ------------------ 5413 # 5414 if( siAnfEntfernen ) : 5415 5416 self.__dbAbfrage__( """ 5417 SELECT intern.loesche__zeile( 'prj.p_prtstrstrkt' 5418 , 'prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 5419 AND prt_protokoll_id = """ + str( werte[i][3] ) + """ 5420 AND str_strkt_id = """ + str( werte[i][0] ) + """' 5421 , 'true');""" )

5422 5423 5424 5425 5426 # 5427 # ------------------------------------------------------------------------------------ 5428 # ------------------------------------------------------------------------------------ 5429 # -- Protokolleintrag und Dokument projektspezifisch verbinden ---------- 5430 # ------------------------------------------------------------------------------------ 5431 # ------------------------------------------------------------------------------------ 5432 #

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

5434 """ 5435 Methode zum Herstellen der projektspezifischen Verbindung zwischen Protokolleintrag und Dokument. 5436 5437 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 5438 @type prtProtokollId: Ganzzahl 5439 5440 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 5441 @type prtProtokollId: Ganzzahl 5442 5443 @param dokDokuId: Es ist die Datenbankidentifikationsnummer (C{dok.doku.id}) des aktuellen Dokumentes zu übergeben, welches dem Protokolleintrag zugeordnet werden soll. 5444 @type dokDokuId: Ganzzahl 5445 5446 @param plPrtDokdoku: Es sind die Detailwerte zum Dokument (C{dok.doku.id}) zu übergeben: C{nr, spr_uebvar_id, spr_uebvar_id_zus, notizen} 5447 @type plPrtDokdoku: Liste 5448 5449 @param plDokAusgabe: Es sind die Detailwerte zur aktuellen Ausgabe des Dokumentes (C{dok.doku.id}) zu übergeben: C{stand, datum, istfrei, notizen}. Wenn keine Ausgabe zugeordnet werden soll, ist C{None} anzugeben. 5450 @type plDokAusgabe: Liste 5451 5452 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 5453 @type logentfernt: Zeichenkette, die C{true/false} enthält 5454 """ 5455 5456 # 5457 # -- in Protokolldatei schreiben ------------------------------------------ 5458 # 5459 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPrtDoku()" 5460 , istKopfzeile = True ) 5461 5462 5463 5464 # 5465 # -- 5466 # -- Protokolleintrag und Dokument verbinden ---------------------------------- 5467 # -- >prj.pl_prtdokdoku< ---------- 5468 # -- ---------- 5469 # -- ---------- 5470 # -- prj.nimm__tabwerte( 'pl_prtdokdoku', ARRAY[ ---------- 5471 # -- 1. prj_projekte_id ---------- 5472 # -- 2. dok_doku_id ---------- 5473 # -- 3. prt_protokoll_id ---------- 5474 # -- 4. nr ---------- 5475 # -- 5. spr_uebvar_id ---------- 5476 # -- 6. logentfernt ---------- 5477 # -- 7. spr_uebvar_id_zus ---------- 5478 # -- 8. notizen ---------- 5479 # -- ---------- 5480 # -- ---------- 5481 # -- -------------------------------------------------------------------------- 5482 # 5483 self.__dbAbfrage__( """ 5484 SELECT prj.nimm__tabwerte( 'pl_prtdokdoku', ARRAY[""" 5485 # 5486 # -- prj_projekte_id ---------------------------------- 5487 # 5488 + "'" + str( self.filter__prj_projekte_id ) + "'" 5489 # 5490 # -- dok_doku_id ------------------------------------------ 5491 # 5492 + ", '" + str( dokDokuId ) + "'" 5493 # 5494 # -- prt_protokoll_id ---------------------------------- 5495 # 5496 + ", '" + str( prtProtokollId ) + "'" 5497 # 5498 # -- nr -------------------------------------------------- 5499 # 5500 + ", '" + str( plPrtDokdoku[0] ) + "'" 5501 # 5502 # -- spr_uebvar_id ------------------------------------------ 5503 # 5504 + ", '" + str( plPrtDokdoku[1] ) + "'" 5505 # 5506 # -- logentfernt ------------------------------------------ 5507 # 5508 + ", '" + str( logentfernt ) + "'" 5509 # 5510 # -- spr_uebvar_id_zus ---------------------------------- 5511 # 5512 + ", '" + str( plPrtDokdoku[2] ) + "'" 5513 # 5514 # -- notizen ------------------------------------------ 5515 # 5516 + ", '" + str( plPrtDokdoku[3] ) + "']);" ) 5517 5518 5519 # 5520 # -- 5521 # -- Personen zuordnen -------------------------------------------------- 5522 # -- >prj.ppl_dokdoku< ---------- 5523 # -- ---------- 5524 # -- Zur vorgegebenen >dok_doku_id< werden die Personen direkt ---------- 5525 # -- aus der Datenbank gelesen und das aktuelle Projekt zugeordnet ---------- 5526 # -- ---------- 5527 # -- ---------- 5528 # -- prj.nimm__tabwerte( 'ppl_dokdoku', ARRAY[ ---------- 5529 # -- 1. prj_projekte_id ---------- 5530 # -- 2. dok_doku_id ---------- 5531 # -- 3. prj_personen_id ---------- 5532 # -- 4. logentfernt ---------- 5533 # -- 5. notizen ---------- 5534 # -- ---------- 5535 # -- ---------- 5536 # -- -------------------------------------------------------------------------- 5537 # 5538 werte = [] 5539 self.__dbAbfrage__( """ 5540 -- 5541 -- Zugeordnete Personen auslesen 5542 -- 5543 SELECT DISTINCT 5544 -- 0 5545 prj__ppl_dokdoku__prj_personen_id AS prj_personen_id 5546 , prj__ppl_dokdoku__notizen AS notizen 5547 FROM 5548 prj.zeige__ppl_dokdoku_le 5549 , prj.zeige__dokdoku 5550 WHERE 5551 -- 5552 -- Ausschließlich die letzten (aktuellen) Personenzuordnungen anzeigen, ... 5553 -- 5554 prj.zeige__ppl_dokdoku_le.prj__ppl_dokdoku__id = 5555 prj.zeige__dokdoku.prj__ppl_dokdoku__id 5556 AND 5557 -- 5558 -- ... die nicht entfernt wurden 5559 -- 5560 prj.zeige__dokdoku.prj__ppl_dokdoku__logentfernt = false 5561 AND 5562 -- 5563 -- Dokument festlegen 5564 -- 5565 prj.zeige__dokdoku.dok__doku__id = """ + str( dokDokuId ) + """ 5566 ;""" ) 5567 5568 for i in range( self.__gibAnzZeilen__() ): 5569 werte.append( [ self.__gibWert__( i, 0 ), self.__gibWert__( i, 1 ) ] ) 5570 5571 for i in range( len( werte ) ) : 5572 self.__dbAbfrage__( """ 5573 SELECT prj.nimm__tabwerte( 'ppl_dokdoku', ARRAY[""" 5574 # 5575 # -- prj_projekte_id ---------------------------------- 5576 # 5577 + "'" + str( self.filter__prj_projekte_id ) + "'" 5578 # 5579 # -- dok_doku_id ------------------------------------------ 5580 # 5581 + ", '" + str( dokDokuId ) + "'" 5582 # 5583 # -- prj_personen_id ------------------------------------------ 5584 # 5585 + ", '" + str( werte[i][0] ) + "'" 5586 # 5587 # -- logentfernt ------------------------------------------ 5588 # 5589 + ", '" + str( logentfernt ) + "'" 5590 # 5591 # -- notizen ------------------------------------------ 5592 # 5593 + ", '" + str( werte[i][1] ) + "']);" ) 5594 5595 5596 5597 # 5598 # -- 5599 # -- Ausgabe zuordnen -------------------------------------------------- 5600 # -- ---------- 5601 # -- >prj.pl_dokausgabe.stand< muß einen Wert haben, sonst ist ---------- 5602 # -- keine Ausgabe zugeordnet ---------- 5603 # -- ---------- 5604 # -- -------------------------------------------------------------------------- 5605 # 5606 if( plDokAusgabe is None ) : return 5607 5608 if( len( str( plDokAusgabe[2] ) ) > 0 ) : 5609 5610 self.schreibe__prjPlDokAusgabe( listeWerte = [ # 5611 # -- dok_doku_id ---------- 5612 # 5613 dokDokuId 5614 # 5615 # -- stand ------------------ 5616 # 5617 , plDokAusgabe[0] 5618 # 5619 # -- datum ------------------ 5620 # 5621 , plDokAusgabe[1] 5622 # 5623 # -- istfrei ------------------ 5624 # 5625 , plDokAusgabe[2] 5626 # 5627 # -- notizen ------------------ 5628 # 5629 , plDokAusgabe[3] ] 5630 # 5631 # -- logentfernt ------------------ 5632 # 5633 , logentfernt = logentfernt )

5634 5635 5636 5637 # 5638 # ------------------------------------------------------------------------------------ 5639 # ------------------------------------------------------------------------------------ 5640 # -- Ausgabe schreiben -------------------------------------------------- 5641 # ------------------------------------------------------------------------------------ 5642 # ------------------------------------------------------------------------------------ 5643 #

5644 - def schreibe__prjPlDokAusgabe( self, listeWerte, logentfernt = 'false' ):

5645 """ 5646 Methode zum Schreiben der Ausgabe eines Dokumentes. 5647 5648 @param listeWerte: Es sind C{dok_doku_id, stand, datum, istfrei, notizen} zu übergeben. 5649 @type listeWerte: Python - Liste 5650 5651 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 5652 @type logentfernt: Zeichenkette, die C{true/false} enthält 5653 """ 5654 5655 # 5656 # -- in Protokolldatei schreiben ------------------------------------------ 5657 # 5658 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPlDokAusgabe()" 5659 , istKopfzeile = True ) 5660 5661 5662 5663 # 5664 # -- 5665 # -- Ausgabe schreiben -------------------------------------------------- 5666 # -- >prj.pl_dokausgabe< ---------- 5667 # -- ---------- 5668 # -- ---------- 5669 # -- prj.nimm__tabwerte( 'pl_dokausgabe', ARRAY[ ---------- 5670 # -- 1. prj_projekte_id ---------- 5671 # -- 2. dok_doku_id ---------- 5672 # -- 3. logentfernt ---------- 5673 # -- 4. stand ---------- 5674 # -- 5. datum ---------- 5675 # -- 6. istfrei ---------- 5676 # -- 7. notizen ---------- 5677 # -- ---------- 5678 # -- ---------- 5679 # -- -------------------------------------------------------------------------- 5680 # 5681 self.__dbAbfrage__( """ 5682 SELECT prj.nimm__tabwerte( 'pl_dokausgabe', ARRAY[""" 5683 # 5684 # -- prj_projekte_id ---------------------------------- 5685 # 5686 + "'" + str( self.filter__prj_projekte_id ) + "'" 5687 # 5688 # -- dok_doku_id ------------------------------------------ 5689 # 5690 + ", '" + str( listeWerte[0] ) + "'" 5691 # 5692 # -- logentfernt ------------------------------------------ 5693 # 5694 + ", '" + str( logentfernt ) + "'" 5695 # 5696 # -- stand -------------------------------------------------- 5697 # 5698 + ", '" + str( listeWerte[1] ) + "'" 5699 # 5700 # -- datum -------------------------------------------------- 5701 # 5702 + ", '" + str( listeWerte[2] ) + "'" 5703 # 5704 # -- istfrei -------------------------------------------------- 5705 # 5706 + ", '" + str( listeWerte[3] ) + "'" 5707 # 5708 # -- notizen ------------------------------------------ 5709 # 5710 + ", '" + str( listeWerte[4] ) + "']);" )

5711 5712 5713 5714 5715 # 5716 # ------------------------------------------------------------------------------------ 5717 # ------------------------------------------------------------------------------------ 5718 # -- Dokument schreiben (Protokolleintrag zuordnen) -------------------------- 5719 # ------------------------------------------------------------------------------------ 5720 # ------------------------------------------------------------------------------------ 5721 #

5722 - def schreibe__prjPlPrtDokDoku( self, listeWerte ):

5723 """ 5724 Methode zum Schreiben eines Dokumentes einschl. Zuordnen des Protokolleintrages. 5725 5726 @param listeWerte: Es sind C{notizen, logentfernt, dok_doku_id, nr, prj_projekte_id, prt_protokoll_id, spr_uebvar_id, spr_uebvar_id_zus} zu übergeben. 5727 @type listeWerte: Python - Liste 5728 """ 5729 5730 5731 5732 # 5733 # -- in Protokolldatei schreiben ------------------------------------------ 5734 # 5735 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPlPrtDokDoku()" 5736 , istKopfzeile = True ) 5737 5738 5739 5740 # 5741 # -- 5742 # -- Protokolleintrag anlegen ------------------------------------------ 5743 # -- >prt.protokoll< ---------- 5744 # -- ---------- 5745 # -- ---------- 5746 # -- intern.nimm__zeile( 'prj.pl_prtdokdoku', ARRAY[ ---------- 5747 # -- , 'notizen' ---------- 5748 # -- , 'logentfernt' ---------- 5749 # -- , 'dok_doku_id' ---------- 5750 # -- , 'nr' ---------- 5751 # -- , 'prj_projekte_id' ---------- 5752 # -- , 'prt_protokoll_id' ---------- 5753 # -- , 'spr_uebvar_id' ---------- 5754 # -- , 'spr_uebvar_id_zus' ---------- 5755 # -- ], ARRAY[...] ) ---------- 5756 # -- ---------- 5757 # -- ---------- 5758 # -- -------------------------------------------------------------------------- 5759 # 5760 self.__dbAbfrage__( """ 5761 SELECT intern.nimm__zeile( 'prj.pl_prtdokdoku', ARRAY[ 'notizen', 'logentfernt', 'dok_doku_id', 'nr', 'prj_projekte_id', 'prt_protokoll_id', 'spr_uebvar_id', 'spr_uebvar_id_zus', 'logdatuhrz' ], ARRAY[ """ 5762 # 5763 # -- notizen -------------------------------------------------- 5764 # 5765 + "'" + listeWerte[0].encode('utf-8') + "'" 5766 # 5767 # -- logentfernt ------------------------------------------ 5768 # 5769 + ", '" + listeWerte[1] + "'" 5770 # 5771 # -- dok_doku_id ------------------------------------------ 5772 # 5773 + ", '" + str( listeWerte[2] ) + "'" 5774 # 5775 # -- nr -------------------------------------------------- 5776 # 5777 + ", '" + listeWerte[3].encode('utf-8') + "'" 5778 # 5779 # -- prj_projekte_id ------------------------------------------ 5780 # 5781 + ", '" + str( listeWerte[4] ) + "'" 5782 # 5783 # -- prt_protokoll_id ---------------------------------- 5784 # 5785 + ", '" + str( listeWerte[5] ) + "'" 5786 # 5787 # -- spr_uebvar_id ------------------------------------------ 5788 # 5789 + ", '" + str( listeWerte[6] ) + "'" 5790 # 5791 # -- spr_uebvar_id_zus ---------------------------------- 5792 # 5793 + ", '" + str( listeWerte[7] ) + "'" 5794 # 5795 # -- logdatuhrz ------------------------------------------ 5796 # 5797 + ", CAST( timeofday() AS varchar )]);" )

5798 5799 5800 5801 5802 5803 5804 # 5805 # ------------------------------------------------------------------------------------ 5806 # ------------------------------------------------------------------------------------ 5807 # -- Protokolleintrag dem Gefahrenszenario zuordnen -------------------------- 5808 # ------------------------------------------------------------------------------------ 5809 # ------------------------------------------------------------------------------------ 5810 #

5811 - def schreibe__prjPlPrtPsGefszenario( self, listeWerte, psGefszenarioId, logentfernt = 'false' ):

5812 """ 5813 Methode zum Herstellen der projektspezifischen Verbindung zwischen Protokolleintrag und Dokument. 5814 5815 @note: Die übergebene Auswahlliste (C{SiAnfStrktDok}) wird verändert ! 5816 5817 @param listeWerte: Es sind die C{prt.protokoll.id} zu übergeben. 5818 @type listeWerte: Python - Liste 5819 5820 @param psGefszenarioId: Es ist die Datenbankidentifikationsnummer (C{ps.gefszenario.id}) des aktuellen Gefahrenszenarios zu übergeben. 5821 @type psGefszenarioId: Ganzzahl 5822 5823 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 5824 @type logentfernt: Zeichenkette, die C{true/false} enthält 5825 """ 5826 5827 # 5828 # -- in Protokolldatei schreiben ------------------------------------------ 5829 # 5830 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPlPrtPsGefszenario()" 5831 , istKopfzeile = True ) 5832 5833 5834 5835 # 5836 # -- alle >prt.protokoll.id< aus der Datenbank holen, die dem ---------- 5837 # -- Gefahrenszenario bereits zugeordnet sind ---------- 5838 # -- (nur beim Zuordnen relevant) ---------- 5839 # 5840 prtProtokollIdZugeordnet = [] 5841 5842 if( logentfernt == 'false' ) : 5843 5844 self.__dbAbfrage__( self.__gibSQL_prjPlPrtPsGefszenario__( psGefszenarioId = psGefszenarioId ) ) 5845 5846 for i in range( self.__gibAnzZeilen__() ): 5847 5848 prtProtokollIdZugeordnet.append( self.__gibWert__( i, 0 ) ) 5849 5850 5851 5852 # 5853 # -- 5854 # -- Protokolleintrag und Gefahrenszenario verbinden -------------------------- 5855 # -- >prj.pl_prtpsgefszenario< ---------- 5856 # -- ---------- 5857 # -- ---------- 5858 # -- prj.nimm__tabwerte( 'pl_prtpsgefszenario', ARRAY[ ---------- 5859 # -- 1. prj_projekte_id ---------- 5860 # -- 2. ps_gefszenario_id ---------- 5861 # -- 3. prt_protokoll_id ---------- 5862 # -- 4. notizen ---------- 5863 # -- 5. logentfernt ---------- 5864 # -- 6. ... ---------- 5865 # -- ---------- 5866 # -- -------------------------------------------------------------------------- 5867 # 5868 for i in range( len( listeWerte ) ) : 5869 5870 # 5871 # -- bereits zugeordnete Protokolleinträge überspringen, ---------- 5872 # -- (beim Entfernen ist >prtProtokollIdZugeordnet< leer ) ---------- 5873 # 5874 if( listeWerte[i] in prtProtokollIdZugeordnet ) : 5875 5876 continue 5877 5878 self.__dbAbfrage__( """ 5879 SELECT prj.nimm__tabwerte( 'pl_prtpsgefszenario', ARRAY[""" 5880 # 5881 # -- prj_projekte_id ---------------------------------- 5882 # 5883 + "'" + str( self.filter__prj_projekte_id ) + "'" 5884 # 5885 # -- ps_gefszenario_id ---------------------------------- 5886 # 5887 + ", '" + str( psGefszenarioId ) + "'" 5888 # 5889 # -- prt_protokoll_id ---------------------------------- 5890 # 5891 + ", '" + str( listeWerte[i] ) + "'" 5892 # 5893 # -- notizen (ggf. später den tatsächlichen Wert übernehmen) -- 5894 # 5895 + ", '" + zk.gibZk( "" ) + "'" 5896 # 5897 # -- logentfernt ------------------------------------------ 5898 # 5899 + ", '" + logentfernt + "']);" )

5900 5901 5902 5903 5904 # 5905 # ------------------------------------------------------------------------------------ 5906 # ------------------------------------------------------------------------------------ 5907 # -- Alle Eingabefelder des Gefahrenprotokolls in Abhängigkeit ---------- 5908 # -- von der gewählten Protokoll.-Id schreiben ---------- 5909 # ------------------------------------------------------------------------------------ 5910 # ------------------------------------------------------------------------------------ 5911 #

5912 - def schreibePrtProtokoll( self, wxCheckBoxIntern, wxCheckBoxErledigt, wxmskCtrlDatumPE, LBSpWTALBetPers, listeWerte, wxmskCtrlAntwDatum, wxmskCtrlTermin, LBSpWTALAntwPers, fallunterscheidung, prtProtokollId ):

5913 """ 5914 Methode zum Einfügen / Aktualisieren der projektspezifischen Informationen in die Datenbanktabellen C{prt.protokoll / prj.pp_prtprotokoll}. 5915 5916 @param wxCheckBoxIntern: CheckBox zur Markierung 'Intern' 5917 @type wxCheckBoxIntern: wxPython - CheckBox 5918 5919 @param wxCheckBoxErledigt: CheckBox zur Markierung 'Erledigt' 5920 @type wxCheckBoxErledigt: wxPython - CheckBox 5921 5922 @param wxmskCtrlDatumPE: Datum-Eingabefeld, zur Spezifikation des Datums des Protokolleintrages 5923 @type wxmskCtrlDatumPE: wxPython - wxmskCtrl 5924 5925 @param LBSpWTALBetPers: Auswahlliste, die die beteiligten Personen aufnimmt 5926 @type LBSpWTALBetPers: ListBoxSpWTitelAL 5927 5928 @param listeWerte: Es sind C{[prj.pp_prtprotokoll.id, notizen]} zu übergeben 5929 @type listeWerte: Python-Liste 5930 5931 @param wxmskCtrlAntwDatum: Datum-Eingabefeld, zur Spezifikation des Datums der Antwort 5932 @type wxmskCtrlAntwDatum: wxPython - wxmskCtrl 5933 5934 @param wxmskCtrlTermin: Datum-Eingabefeld, zur Spezifikation des Termins 5935 @type wxmskCtrlTermin: wxPython - wxmskCtrl 5936 5937 @param LBSpWTALAntwPers: Auswahlliste, die die angesprochenen Personen aufnimmt 5938 @type LBSpWTALAntwPers: ListBoxSpWTitelAL 5939 5940 @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. 5941 @type fallunterscheidung: 5942 5943 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Protokolleintrages zu übergeben. 5944 @type prtProtokollId: Ganzzahl 5945 """ 5946 5947 # 5948 # -- in Protokolldatei schreiben ------------------------------------------ 5949 # 5950 self.ProtokolldateiEintragen( eintrag = "schreibePrtProtokoll()" 5951 , istKopfzeile = True ) 5952 5953 5954 5955 5956 # 5957 # -- 5958 # -- Übersetzungsvariante >spr.uebvar< bereitstellen / bearbeiten ---------- 5959 # -- ---------- 5960 # -- ---------- 5961 # -- Rechtschreibfehlerkorrekturen >istRFKorr = True< haben globale ---------- 5962 # -- Auswirkungen (werden projektübergreifend übernommen) ---------- 5963 # -- Neben den Tabellen der Sicht >spr< werden keine weiteren ---------- 5964 # -- Datenbanktabellen verändert, deshalb wird die Änderung als ---------- 5965 # -- 'bearbeitet' markiert ---------- 5966 # -- ---------- 5967 # -- ---------- 5968 # -- Es werden drei Fälle abgedeckt: ---------- 5969 # -- ............................... ---------- 5970 # -- ---------- 5971 # -- 1. projektspezifischer Protokolleintrag ---------- 5972 # -- id > 0 AND prj_personen_id = 0 AND ---------- 5973 # -- prj_projekte_id > 0 AND prt_protokoll_id > 0 ---------- 5974 # -- ---------- 5975 # -- 2. beteiligte Personen zuordnen ---------- 5976 # -- id > 0 AND prj_personen_id > 0 AND prj_projekte_id > 0 ---------- 5977 # -- AND prt_protokoll_id > 0 AND spr_uebvar_id = 0 ---------- 5978 # -- AND teilnehmer = true ---------- 5979 # -- ---------- 5980 # -- 3. der Protokolleintrag ist eine Frage / Aufgabe ---------- 5981 # -- id > 0 AND prj_personen_id > 0 AND prj_projekte_id > 0 ---------- 5982 # -- AND prt_protokoll_id > 0 AND spr_uebvar_id = 0 ---------- 5983 # -- AND teilnehmer = false AND termin IS NOT NULL ---------- 5984 # -- ---------- 5985 # -- ---------- 5986 # -- Änderungen (Zeilen) in Liste schreiben (Tabelle ---------- 5987 # -- >prj.pp_prtprotokoll<) : ---------- 5988 # -- ---------- 5989 # -- werte[ 0 id ---------- 5990 # -- 1 notizen ---------- 5991 # -- 2 datuhrz ---------- 5992 # -- 3 duanfrage ---------- 5993 # -- 4 erledigt ---------- 5994 # -- 5 intern ---------- 5995 # -- 6 prj_personen_id ---------- 5996 # -- 7 prj_projekte_id ---------- 5997 # -- 8 prt_protokoll_id ---------- 5998 # -- 9 spr_uebvar_id ---------- 5999 # -- 10 teilnehmer ---------- 6000 # -- 11 termin ] ---------- 6001 # -- ---------- 6002 # -- ---------- 6003 # -- -------------------------------------------------------------------------- 6004 # 6005 werte = [] 6006 6007 6008 # 6009 # -- 6010 # -- 1. projektspezifischer Protokolleintrag -------------------------- 6011 # -- 6012 # 6013 if( fallunterscheidung is None ) : 6014 6015 werte.append( [ listeWerte[0] 6016 , listeWerte[2] 6017 , wxmskCtrlDatumPE.gibWert() 6018 , None 6019 , wxCheckBoxErledigt.gibWert() 6020 , wxCheckBoxIntern.gibWert() 6021 , 0 6022 , self.filter__prj_projekte_id 6023 , prtProtokollId 6024 , listeWerte[1] 6025 , None 6026 , None] ) 6027 6028 6029 6030 # 6031 # -- 6032 # -- 2. Beteiligte Personen -------------------------------------------------- 6033 # -- 6034 # 6035 if( LBSpWTALBetPers.ListBox__li.gibClientData() == None ): 6036 tmp = 0 6037 else : 6038 tmp = len( LBSpWTALBetPers.ListBox__li.gibClientData() ) 6039 6040 if( fallunterscheidung == True ) : 6041 6042 for i in range( tmp ): 6043 if( i < len( LBSpWTALBetPers.ListBox__li.clientData ) ) : 6044 # Personen übernehmen / überschreiben 6045 werte.append( [ LBSpWTALBetPers.ListBox__li.clientData[i] 6046 , None 6047 , None 6048 , None 6049 , None 6050 , None 6051 , LBSpWTALBetPers.ListBox__li.gibClientData(i)[0] 6052 , self.filter__prj_projekte_id 6053 , prtProtokollId 6054 , None 6055 , 'true' 6056 , None] ) 6057 else : 6058 # Personen hinzufügen 6059 werte.append( [ None 6060 , None 6061 , None 6062 , None 6063 , None 6064 , None 6065 , LBSpWTALBetPers.ListBox__li.gibClientData(i)[0] 6066 , self.filter__prj_projekte_id 6067 , prtProtokollId 6068 , None 6069 , 'true' 6070 , None] ) 6071 # Personen löschen 6072 for i in range( tmp, len( LBSpWTALBetPers.ListBox__li.clientData ) ): 6073 werte.append( [ LBSpWTALBetPers.ListBox__li.clientData[i] 6074 , None 6075 , None 6076 , None 6077 , None 6078 , None 6079 , None 6080 , self.filter__prj_projekte_id 6081 , prtProtokollId 6082 , None 6083 , 'true' 6084 , None] ) 6085 6086 6087 # 6088 # -- 3. der Protokolleintrag ist eine Frage / Aufgabe ------------------ 6089 # 6090 if( LBSpWTALAntwPers.ListBox__li.gibClientData() == None ): 6091 tmp = 0 6092 else : 6093 tmp = len( LBSpWTALAntwPers.ListBox__li.gibClientData() ) 6094 6095 if( fallunterscheidung == False ) : 6096 6097 for i in range( tmp ): 6098 if( i < len( LBSpWTALAntwPers.ListBox__li.clientData ) ) : 6099 # Personen übernehmen / überschreiben 6100 werte.append( [ LBSpWTALAntwPers.ListBox__li.clientData[i] 6101 , None 6102 , None 6103 , wxmskCtrlAntwDatum.gibWert() 6104 , None 6105 , None 6106 , LBSpWTALAntwPers.ListBox__li.gibClientData(i) 6107 , self.filter__prj_projekte_id 6108 , prtProtokollId 6109 , None 6110 , 'false' 6111 , wxmskCtrlTermin.gibWert()] ) 6112 else : 6113 # Personen hinzufügen 6114 werte.append( [ None 6115 , None 6116 , None 6117 , wxmskCtrlAntwDatum.gibWert() 6118 , None 6119 , None 6120 , LBSpWTALAntwPers.ListBox__li.gibClientData(i) 6121 , self.filter__prj_projekte_id 6122 , prtProtokollId 6123 , None 6124 , 'false' 6125 , wxmskCtrlTermin.gibWert()] ) 6126 6127 # Personen löschen 6128 for i in range( tmp, len( LBSpWTALAntwPers.ListBox__li.clientData ) ): 6129 if( i < len( LBSpWTALAntwPers.ListBox__li.clientData ) ) : 6130 werte.append( [ LBSpWTALAntwPers.ListBox__li.clientData[i] 6131 , None 6132 , None 6133 , wxmskCtrlAntwDatum.gibWert() 6134 , None 6135 , None 6136 , None 6137 , self.filter__prj_projekte_id 6138 , prtProtokollId 6139 , None 6140 , 'false' 6141 , wxmskCtrlTermin.gibWert()] ) 6142 6143 6144 6145 # 6146 # -- 6147 # -- >prj.pp_prtprotokoll< -------------------------------------------------- 6148 # -- ---------- 6149 # -- ---------- 6150 # -- Es werden die projektspezifisch gültigen Zeilen eingelesen. ---------- 6151 # -- Wenn werte[6] == None (aktuelle >prj_personen_id< entfernt ---------- 6152 # -- wurde) wird der zugeordnete Protokolleintrag ---------- 6153 # -- >prj.pp_prtprotokoll.id< entfernt. ---------- 6154 # -- ---------- 6155 # -- ---------- 6156 # -- -------------------------------------------------------------------------- 6157 # 6158 for i in range( len( werte ) ) : 6159 6160 # 6161 # -- 6162 # -- Protokolleinträge aus >prj.pp_prtprotokoll< entfernen ---------- 6163 # -- -- 6164 # -- -- 6165 # -- SELECT intern.loesche__zeile( 'prj.pp_prtprotokoll' -- 6166 # -- , 'prj.pp_prtprotokoll.id = werte[i][0]' ); -- 6167 # -- -- 6168 # -- -- 6169 # -- ------------------------------------------------------------------ 6170 # 6171 if( werte[i][6] == None ) : 6172 6173 self.__dbAbfrage__( """ 6174 SELECT intern.loesche__zeile( 'prj.pp_prtprotokoll' 6175 , 'prj.pp_prtprotokoll.id = """ + str( werte[i][0] ) + """' 6176 , 'true');""" ) 6177 6178 6179 # 6180 # -- 6181 # -- Projektspezifische Zeilen einlesen -------------------------- 6182 # -- -- 6183 # -- -- 6184 # -- intern.nimm__zeile( 'prj.pp_prtprotokoll', ARRAY[ -- 6185 # -- 'id' -- 6186 # -- , 'notizen' -- 6187 # -- , 'datuhrz' -- 6188 # -- , 'duanfrage' -- 6189 # -- , 'erledigt' -- 6190 # -- , 'intern' -- 6191 # -- , 'prj_personen_id' -- 6192 # -- , 'prj_projekte_id' -- 6193 # -- , 'prt_protokoll_id' -- 6194 # -- , 'spr_uebvar_id' -- 6195 # -- , 'teilnehmer' -- 6196 # -- , 'termin' -- 6197 # -- ], ARRAY[...] ) -- 6198 # -- -- 6199 # -- Es werden die bisher bestehenden projektspezifischen Zeilen -- 6200 # -- überschrieben. -- 6201 # -- -- 6202 # -- -- 6203 # -- ------------------------------------------------------------------ 6204 # 6205 else : 6206 sql = "SELECT intern.nimm__zeile( 'prj.pp_prtprotokoll', ARRAY[" 6207 # 6208 # -- 0. id -------------------------------------------------- 6209 # 6210 if( werte[i][0] != None ) : sql = sql + "'id', " 6211 # 6212 # -- 1. notizen -------------------------------------------------- 6213 # 6214 if( werte[i][1] != None ) : sql = sql + "'notizen', " 6215 # 6216 # -- 2. datuhrz -------------------------------------------------- 6217 # 6218 if( werte[i][2] != None ) : sql = sql + "'datuhrz', " 6219 # 6220 # -- 3. duanfrage ------------------------------------------ 6221 # 6222 if( werte[i][3] != None ) : sql = sql + "'duanfrage', " 6223 # 6224 # -- 4. erledigt ------------------------------------------ 6225 # 6226 if( werte[i][4] != None ) : sql = sql + "'erledigt', " 6227 # 6228 # -- 5. intern -------------------------------------------------- 6229 # 6230 if( werte[i][5] != None ) : sql = sql + "'intern', " 6231 # 6232 # -- 6. prj_personen_id ------------------------------------------ 6233 # 6234 if( werte[i][6] != None ) : sql = sql + "'prj_personen_id', " 6235 # 6236 # -- 7 prj_projekte_id ------------------------------------------ 6237 # 6238 sql = sql + "'prj_projekte_id', " 6239 # 6240 # -- 8 prt_protokoll_id ---------------------------------- 6241 # 6242 sql = sql + "'prt_protokoll_id', " 6243 # 6244 # -- 9. spr_uebvar_id ------------------------------------------ 6245 # 6246 if( werte[i][9] != None ) : sql = sql + "'spr_uebvar_id', " 6247 # 6248 # -- 10. teilnehmer ------------------------------------------ 6249 # 6250 if( werte[i][10] != None ) : sql = sql + "'teilnehmer', " 6251 # 6252 # -- 11. termin -------------------------------------------------- 6253 if( werte[i][11] != None ) : sql = sql + "'termin', " 6254 6255 sql = sql + "], ARRAY['" 6256 6257 # 6258 # -- 0 id -------------------------------------------------- 6259 # 6260 if( werte[i][0] != None ) : sql = sql + str( werte[i][0] ) + """', '""" 6261 # 6262 # -- 1 notizen -------------------------------------------------- 6263 # 6264 if( werte[i][1] != None ) : sql = sql + str( werte[i][1] ) + """', '""" 6265 # 6266 # -- 2 datuhrz -------------------------------------------------- 6267 # 6268 if( werte[i][2] != None ) : sql = sql + zk.gibDatum( werte[i][2] ) + """', '""" 6269 # 6270 # -- 3 duanfrage ------------------------------------------ 6271 # 6272 if( werte[i][3] != None ) : sql = sql + zk.gibDatum( werte[i][3] ) + """', '""" 6273 # 6274 # -- 4 erledigt ------------------------------------------ 6275 # 6276 if( werte[i][4] != None ) : sql = sql + str( werte[i][4] ) + """', '""" 6277 # 6278 # -- 5 intern -------------------------------------------------- 6279 # 6280 if( werte[i][5] != None ) : sql = sql + str( werte[i][5] ) + """', '""" 6281 # 6282 # -- 6 prj_personen_id ------------------------------------------ 6283 # 6284 if( werte[i][6] != None ) : sql = sql + str( werte[i][6] ) + """', '""" 6285 # 6286 # -- 7 prj_projekte_id ------------------------------------------ 6287 # 6288 sql = sql + str( werte[i][7] ) + """', '""" 6289 # 6290 # -- 8 prt_protokoll_id ---------------------------------- 6291 # 6292 sql = sql + str( werte[i][8] ) + """', '""" 6293 # 6294 # -- 9 spr_uebvar_id ------------------------------------------ 6295 # 6296 if( werte[i][9] != None ) : sql = sql + str( werte[i][9] ) + """', '""" 6297 # 6298 # -- 10 teilnehmer ------------------------------------------ 6299 # 6300 if( werte[i][10] != None ) : sql = sql + str( werte[i][10] ) + """', '""" 6301 # 6302 # -- 11 termin -------------------------------------------------- 6303 if( werte[i][11] != None ) : sql = sql + zk.gibDatum( werte[i][11] ) + """', '""" 6304 6305 sql = sql + "']);" 6306 sql = sql.replace( ", ]", "]" ).replace( ", ''", "" ) 6307 6308 self.__dbAbfrage__( sql )

6309 6310 6311 6312 6313 # 6314 # ------------------------------------------------------------------------------------ 6315 # ------------------------------------------------------------------------------------ 6316 # -- Protokolleinträge verbinden ------------------------------------------ 6317 # ------------------------------------------------------------------------------------ 6318 # ------------------------------------------------------------------------------------ 6319 #

6320 - def schreibe__prjPPrtVerbindung( self, prjProjekteId, prtProtokollIdVorg, prtProtokollIdNachf, trennen = False ):

6321 """ 6322 Methode zum Herstellen der projektspezifischen Verbindung zwischen den Protokolleinträgen. 6323 6324 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 6325 @type prjProjekteId: Ganzzahl 6326 6327 @param prtProtokollIdVorg: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Vorgängers anzugeben. 6328 @type prtProtokollIdVorg: Ganzzahl 6329 6330 @param prtProtokollIdNachf: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Nachfolgers anzugeben. 6331 @type prtProtokollIdNachf: Ganzzahl 6332 6333 @param trennen: Es ist C{True} anzugeben, wenn die Protokolleinträge voneinander getrennt werden sollen. 6334 @type trennen: Boolean 6335 """ 6336 6337 # 6338 # -- in Protokolldatei schreiben ------------------------------------------ 6339 # 6340 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPPrtVerbindung()" 6341 , istKopfzeile = True ) 6342 6343 6344 6345 # 6346 # -- 6347 # -- Protokolleinträge trennen ------------------------------------------ 6348 # -- >prj.p_prtverbindung< ---------- 6349 # -- ---------- 6350 # -- ---------- 6351 # -- SELECT intern.loesche__zeile( 'prj.p_prtverbindung' ---------- 6352 # -- , 'prj_projekte_id = prjProjekteId ---------- 6353 # -- AND prt_protokoll_id_nachf = prtProtokollIdNachf ---------- 6354 # -- AND prt_protokoll_id_vorg = prtProtokollIdVorg' ---------- 6355 # -- , 'true' ); ---------- 6356 # -- ---------- 6357 # -- ---------- 6358 # -- -------------------------------------------------------------------------- 6359 # 6360 if( trennen ): 6361 6362 self.__dbAbfrage__( """ 6363 SELECT intern.loesche__zeile( 'prj.p_prtverbindung' 6364 , 'prj_projekte_id = """ + str( prjProjekteId ) + """ 6365 AND prt_protokoll_id_nachf = """ + str( prtProtokollIdNachf ) + """ 6366 AND prt_protokoll_id_vorg = """ + str( prtProtokollIdVorg ) + """' 6367 , 'true' );""" ) 6368 6369 6370 # 6371 # -- 6372 # -- Protokolleinträge miteinander verbinden -------------------------- 6373 # -- >prj.p_prtverbindung< ---------- 6374 # -- ---------- 6375 # -- ---------- 6376 # -- prj.nimm__tabwerte( 'p_prtverbindung', ARRAY[ ---------- 6377 # -- 1. prj_projekte_id ---------- 6378 # -- 2. prt_protokoll_id_nachf ---------- 6379 # -- 3. prt_protokoll_id_vorg ---------- 6380 # -- 4. ... ---------- 6381 # -- ---------- 6382 # -- -------------------------------------------------------------------------- 6383 # 6384 else : 6385 6386 self.__dbAbfrage__( """ 6387 SELECT prj.nimm__tabwerte( 'p_prtverbindung', ARRAY[""" 6388 # 6389 # -- prj_projekte_id ---------------------------------- 6390 # 6391 + "'" + str( prjProjekteId ) + "'" 6392 # 6393 # -- prt_protokoll_id_nachf ---------------------------------- 6394 # 6395 + ", '" + str( prtProtokollIdNachf ) + "'" 6396 # 6397 # -- prt_protokoll_id_vorg ---------------------------------- 6398 # 6399 + ", '" + str( prtProtokollIdVorg ) + "']);" )

6400 6401 6402 6403 6404 6405 6406 6407 # 6408 # ------------------------------------------------------------------------------------ 6409 # ------------------------------------------------------------------------------------ 6410 # -- Protokolleintrag dem Gefahrenszenario zuordnen -------------------------- 6411 # -- Protokolleintrag vom Gefahrenszenario trennen -------------------------- 6412 # ------------------------------------------------------------------------------------ 6413 # ------------------------------------------------------------------------------------ 6414 #

6415 - def schreibePrtProtokollVerbindung( self, TreeCtrlErg, prtProtokollIdVorg, ignoriereSprSprachenId = False, ignorierePsGefszenarioId = False ):

6416 """ 6417 Methode zum Herstellen bzw. Aufheben der projektspezifischen Verbindung zwischen den Protokolleinträgen. 6418 6419 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die Protokolleinträge enthält, die zugeordnet bzw. entfernt werden soll. 6420 @type TreeCtrlErg: TreeCtrlErg 6421 6422 @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. 6423 @type prtProtokollIdVorg: Ganzzahl 6424 6425 @param ignorierePsGefszenarioId: Es ist die C{True} anzugeben, wenn C{self.ps_gefszenario_id} in der SQL-Abfrage berücksichtigt werden soll. 6426 @type ignorierePsGefszenarioId: Boolean 6427 """ 6428 6429 # 6430 # -- in Protokolldatei schreiben ------------------------------------------ 6431 # 6432 self.ProtokolldateiEintragen( eintrag = "schreibePrtProtokollVerbindung()" 6433 , istKopfzeile = True ) 6434 6435 6436 6437 # 6438 # -- Zweig der selektierten Protokolleinträge bestimmen ------------------ 6439 # 6440 eintragListe = TreeCtrlErg.gibZweig() 6441 6442 6443 # 6444 # -- 6445 # -- Verbindung zwischen den Protokolleinträgen aufheben ------------------ 6446 # -- >prj.p_prtverbindung< ------------------ 6447 # -- ------------------ 6448 # 6449 if( prtProtokollIdVorg is None ) : 6450 6451 # 6452 # -- Es sind keine Verbindungen zwischen den SiAnf zu trennen -- 6453 # 6454 if( len( eintragListe ) == 1 6455 and ( TreeCtrlErg.GetItemParent( eintragListe[0] ) == TreeCtrlErg.GetRootItem() ) ) : 6456 6457 return 6458 6459 # 6460 # -- DB-Id des Vorgängers ermitteln, ggf. >eintragListe< kürzen -- 6461 # 6462 if( len( eintragListe ) == 1 ) : 6463 6464 prt_protokoll_id_vorg = TreeCtrlErg.gibDbId( TreeCtrlErg.GetItemParent( eintragListe[0] ) ) 6465 6466 else : 6467 6468 prt_protokoll_id_vorg = TreeCtrlErg.gibDbId( eintragListe[0] ) 6469 del eintragListe[0] 6470 6471 6472 6473 # 6474 # -- Protokolleinträge ermitteln, die demselben Vorgänger in einem -- 6475 # -- weiteren Gefahrenszenario des Projektes zugeordnet sind -- 6476 # 6477 prtProtokollIdListe = "" 6478 6479 for i in range( len( eintragListe ) ) : 6480 6481 if( i > 0 ) : prtProtokollIdListe = prtProtokollIdListe + ', ' 6482 prtProtokollIdListe = prtProtokollIdListe + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) 6483 6484 6485 self.__dbAbfrage__( self.__gibSQL_psPrtProtokoll__( prtTypAspekt = 'SF' 6486 , prtTypId = None 6487 , sqlINpsGefszenId = False 6488 , prtProtokollIdVorg = prt_protokoll_id_vorg 6489 , prtProtokollIdNachf = prtProtokollIdListe 6490 , ignorierePrjProjekteId = False 6491 , ignoriereSprSprachenId = ignoriereSprSprachenId 6492 , ignorierePsGefszenarioId = ignorierePsGefszenarioId ) ) 6493 6494 prtProtokollIdNichtTrennen = [] 6495 6496 for i in range( self.__gibAnzZeilen__() ) : prtProtokollIdNichtTrennen.append( self.__gibWert__( i, 3 ) ) 6497 6498 6499 # 6500 # -- Datenbank aktualisieren ------------------------------------------ 6501 # 6502 for i in range( len( eintragListe ) ) : 6503 6504 # 6505 # -- Protokolleinträge die demselben Vorgänger in einem ---------- 6506 # -- weiteren Gefahrenszenario des Projektes zugeordnet ---------- 6507 # -- sind, nicht trennen ---------- 6508 # 6509 if( TreeCtrlErg.gibDbId( eintragListe[i] ) in prtProtokollIdNichtTrennen ) : 6510 6511 continue 6512 6513 6514 self.schreibe__prjPPrtVerbindung( prjProjekteId = 0 6515 , prtProtokollIdVorg = prt_protokoll_id_vorg 6516 , prtProtokollIdNachf = TreeCtrlErg.gibDbId( eintragListe[i] ) ) 6517 6518 6519 # 6520 # -- Verbindung im Projekt löschen ---------------------------------- 6521 # 6522 self.__dbAbfrage__( """ 6523 SELECT intern.loesche__zeile( 'prj.p_prtverbindung' 6524 , 'prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 6525 AND prt_protokoll_id_nachf = """ + str( TreeCtrlErg.gibDbId( eintragListe[i] ) ) + """ 6526 AND prt_protokoll_id_vorg = """ + str( prt_protokoll_id_vorg ) + """' 6527 , 'true');""" ) 6528 6529 6530 # 6531 # -- Ende, Verbindung aufheben ---------------------------------- 6532 # 6533 return 6534 6535 6536 # 6537 # -- 6538 # -- Protokolleinträge miteinander verbinden -------------------------- 6539 # -- >prj.p_prtverbindung< ---------- 6540 # -- ---------- 6541 # -- ---------- 6542 # -- prj.nimm__tabwerte( 'p_prtverbindung', ARRAY[ ---------- 6543 # -- 1. prj_projekte_id ---------- 6544 # -- 2. prt_protokoll_id_nachf ---------- 6545 # -- 3. prt_protokoll_id_vorg ---------- 6546 # -- 4. ... ---------- 6547 # -- ---------- 6548 # -- -------------------------------------------------------------------------- 6549 # 6550 for i in range( len( eintragListe ) ) : 6551 6552 # 6553 # -- Technische Maßnahmen überspringen -------------------------- 6554 # 6555 if( TreeCtrlErg.gibClientData( eintragListe[i] )[0] == True ) : 6556 6557 continue 6558 6559 6560 self.schreibe__prjPPrtVerbindung( prjProjekteId = self.filter__prj_projekte_id 6561 , prtProtokollIdVorg = prtProtokollIdVorg 6562 , prtProtokollIdNachf = TreeCtrlErg.gibDbId( eintragListe[i] ) )

6563 6564 6565 6566 6567 6568 6569 # 6570 # ------------------------------------------------------------------------------------ 6571 # ------------------------------------------------------------------------------------ 6572 # -- Protokolleintrag dem Projekt zuordnen ---------------------------------- 6573 # ------------------------------------------------------------------------------------ 6574 # ------------------------------------------------------------------------------------ 6575 #

6576 - def schreibe__prjPPPrtProtokoll( self, listeWerte ):

6577 """ 6578 Methode zum Herstellen/Trennen der projektspezifischen Verbindung zwischen den Protokolleinträgen in C{listeWerte} und dem Projekt. 6579 6580 @param listeWerte: Es ist die Liste der Werte zu übergeben, die den Protokolleinträgen zugeordnet sind, die dem Projekt zugeordnet bzw. aus dem Projekt entfernt werden sollen. Es ist zu übergeben [[prt.protokoll.id, prt.protokoll.id, spr.uebvar.id, notizen], [...], ...] 6581 @type listeWerte: TreeCtrlErg 6582 """ 6583 6584 # 6585 # -- in Protokolldatei schreiben ------------------------------------------ 6586 # 6587 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPPPrtProtokoll()" 6588 , istKopfzeile = True ) 6589 6590 6591 6592 # 6593 # -- alle >prt.protokoll.id< aus der Datenbank holen, die dem ---------- 6594 # -- Projekt bereits zugeordnet sind ---------- 6595 # 6596 prtProtokollIdZugeordnet = [] 6597 6598 self.__dbAbfrage__( self.__gibSQL_prjPlPrtPsGefszenario__() ) 6599 6600 for i in range( self.__gibAnzZeilen__() ): 6601 6602 prtProtokollIdZugeordnet.append( self.__gibWert__( i, 0 ) ) 6603 6604 6605 # 6606 # -- 6607 # -- Protokolleintrag dem Projekt zuordnen ---------------------------------- 6608 # -- >prj.pp_prtprotokoll< ---------- 6609 # -- ---------- 6610 # -- ---------- 6611 # -- prj.nimm__tabwerte( 'pp_prtprotokoll', ARRAY[ ---------- 6612 # -- 1. prj_projekte_id ---------- 6613 # -- 2. prt_protokoll_id ---------- 6614 # -- 3. spr_uebvar_id ---------- 6615 # -- 4. datuhrz ---------- 6616 # -- 5. intern ---------- 6617 # -- 6. erledigt ---------- 6618 # -- 7. notizen ]... ---------- 6619 # -- ---------- 6620 # -- -------------------------------------------------------------------------- 6621 # 6622 for i in range( len( listeWerte ) ) : 6623 6624 # 6625 # -- bereits zugeordnete Protokolleinträge überspringen, ---------- 6626 # -- (beim Entfernen ist >prtProtokollIdZugeordnet< leer ) ---------- 6627 # 6628 if( listeWerte[i][0] in prtProtokollIdZugeordnet ) : 6629 6630 continue 6631 6632 self.__dbAbfrage__( """ 6633 SELECT prj.nimm__tabwerte( 'pp_prtprotokoll', ARRAY[""" 6634 # 6635 # -- prj_projekte_id ---------------------------------- 6636 # 6637 + "'" + str( self.filter__prj_projekte_id ) + "'" 6638 # 6639 # -- prt_protokoll_id ---------------------------------- 6640 # 6641 + ", '" + str( listeWerte[i][0] ) + "'" 6642 # 6643 # -- spr_uebvar_id ---------------------------------- 6644 # 6645 + ", '" + str( listeWerte[i][2] ) + "'" 6646 # 6647 # -- datuhrz ------------------------------------------ 6648 # -- intern ------------------------------------------ 6649 # -- erledigt ------------------------------------------ 6650 # 6651 + ", to_char( clock_timestamp(), 'YYYY-MM-DD HH24:MI:SS'), 'true', 'false'" 6652 # 6653 # -- notizen ------------------------------------------ 6654 # 6655 + ", '" + str( listeWerte[i][3] ) + "']);" )

6656 6657 6658 6659 6660 6661 6662 # 6663 # ------------------------------------------------------------------------------------ 6664 # ------------------------------------------------------------------------------------ 6665 # -- Protokolleintrag mittels UPDATE aktualisieren -------------------------- 6666 # ------------------------------------------------------------------------------------ 6667 # ------------------------------------------------------------------------------------ 6668 #

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

6670 """ 6671 Methode zum Aktualisieren eines projektspezifischen Protokolleintrages C{prj.pp_prtprotokoll} mittels C{UPDATE}. 6672 6673 @param sprUebvarId: Es ist die Datenbankidentifikationsnummer (C{spr.uebvar.id}) der Übersetzungsvariante zu übergeben, die in C{prj.pp_prtprotokoll} übernommen werden soll. 6674 @type sprUebvarId: Ganzzahl 6675 6676 @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. 6677 @type whereId: Python-Liste 6678 """ 6679 6680 # 6681 # -- in Protokolldatei schreiben ------------------------------------------ 6682 # 6683 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPPPrtProtokoll__UPDATE()" 6684 , istKopfzeile = True ) 6685 6686 6687 6688 # 6689 # -- Datenbank aktualisieren ------------------------------------------ 6690 # 6691 self.__dbAbfrage__( """ 6692 UPDATE prj.pp_prtprotokoll SET spr_uebvar_id = """ + str( sprUebvarId ) + """ 6693 WHERE prj_projekte_id = """ + str( whereId[0] ) + """ 6694 AND prt_protokoll_id = """ + str( whereId[1] ) + """ 6695 AND spr_uebvar_id = """ + str( whereId[2] ) + """;""" )

6696 6697 6698 6699 # 6700 # ------------------------------------------------------------------------------------ 6701 # ------------------------------------------------------------------------------------ 6702 # -- Protokolleinträge verbinden ------------------------------------------ 6703 # ------------------------------------------------------------------------------------ 6704 # ------------------------------------------------------------------------------------ 6705 #

6706 - def schreibe__prjPPPrtProtokoll_Pers( self, listeWerte, prtProtokollId, prjPersonenId ):

6707 """ 6708 Methode zum Einlesen der personenbezogenen Protokolleinträgen. 6709 6710 @param listeWerte: Es sind C{[teilnehmer, termin, duanfrage, notizen]} zu übergeben 6711 @type listeWerte: Python Liste 6712 6713 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) anzugeben. 6714 @type prtProtokollId: Ganzzahl 6715 6716 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) anzugeben. 6717 @type prtProtokollId: Ganzzahl 6718 6719 @param prjPersonenId : Es ist die Personen-Id C{prj.personen.id} zu übergeben. 6720 @type prjPersonenId : C{Ganzzahl} 6721 """ 6722 6723 # 6724 # -- in Protokolldatei schreiben ------------------------------------------ 6725 # 6726 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPPPrtProtokoll_Pers()" 6727 , istKopfzeile = True ) 6728 6729 6730 6731 # 6732 # -- 6733 # -- Protokolleintrag dem Projekt zuordnen ---------------------------------- 6734 # -- >prj.pp_prtprotokoll< ---------- 6735 # -- ---------- 6736 # -- ---------- 6737 # -- prj.nimm__tabwerte( 'pp_prtprotokoll_pers', ARRAY[ ---------- 6738 # -- 'prj_projekte_id' ---------- 6739 # -- , 'prt_protokoll_id' ---------- 6740 # -- , 'teilnehmer' ---------- 6741 # -- , 'prj_personen_id' ---------- 6742 # -- , 'termin' ---------- 6743 # -- , 'duanfrage' ---------- 6744 # -- , 'notizen' ] ---------- 6745 # -- ---------- 6746 # -- -------------------------------------------------------------------------- 6747 # 6748 self.__dbAbfrage__( """ 6749 SELECT prj.nimm__tabwerte( 'pp_prtprotokoll_pers', ARRAY[""" 6750 # 6751 # -- prj_projekte_id ---------------------------------- 6752 # 6753 + "'" + str( self.filter__prj_projekte_id ) + "'" 6754 # 6755 # -- prt_protokoll_id ---------------------------------- 6756 # 6757 + ", '" + str( prtProtokollId ) + "'" 6758 # 6759 # -- teilnehmer ---------------------------------- 6760 # 6761 + ", '" + str( listeWerte[0] ) + "'" 6762 # 6763 # -- prj_personen_id ---------------------------------- 6764 # 6765 + ", '" + str( prjPersonenId ) + "'" 6766 # 6767 # -- termin ------------------------------------------ 6768 # 6769 + ", " + listeWerte[1] 6770 # 6771 # -- duanfrage ------------------------------------------ 6772 # 6773 + ", " + listeWerte[2] 6774 # 6775 # -- notizen ------------------------------------------ 6776 # 6777 + ", '" + str( listeWerte[3] ) + "']);" )

6778 6779 6780 6781 6782 6783 # 6784 # ------------------------------------------------------------------------------------ 6785 # ------------------------------------------------------------------------------------ 6786 # -- Tabelle >prj.pl_psgefabk< schreiben ---------------------------------- 6787 # ------------------------------------------------------------------------------------ 6788 # ------------------------------------------------------------------------------------ 6789 #

6790 - def schreibe__prjPlPsGefsabk( self, listeWerte, logentfernt = 'false' ):

6791 """ 6792 Methode zum Übernehmen der projektspezifischen Abkürzungen bezogen auf das Gefahrenszenario. 6793 6794 @param listeWerte: Es sind C{[ps_abk_id, spr_uebvar_id_zus, notizen]} zu übergeben 6795 @type listeWerte: Python Liste 6796 6797 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 6798 @type logentfernt: Zeichenkette, die C{true/false} enthält 6799 """ 6800 6801 # 6802 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 6803 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 6804 # 6805 if( self.ps_gefszenario_id is None ) : 6806 6807 return 6808 6809 6810 6811 # 6812 # -- in Protokolldatei schreiben ------------------------------------------ 6813 # 6814 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPlPsGefsabk()" 6815 , istKopfzeile = True ) 6816 6817 6818 6819 # 6820 # -- 6821 # -- Projektspezifische Zeilen einlesen -------------------------- 6822 # -- -- 6823 # -- -- 6824 # -- prj.nimm__tabwerte( 'pl_psgefabk', ARRAY[ -- 6825 # -- 1. prj_projekte_id -- 6826 # -- 2. ps_gefszenario_id -- 6827 # -- 3. logentfernt -- 6828 # -- 4. ps_abk_id -- 6829 # -- 5. spr_uebvar_id_zus -- 6830 # -- 6. notizen -- 6831 # -- 7. ... ] ) -- 6832 # -- -- 6833 # -- -- 6834 # -- ------------------------------------------------------------------ 6835 # 6836 self.__dbAbfrage__( """ 6837 SELECT prj.nimm__tabwerte( 'pl_psgefabk', ARRAY[""" 6838 # 6839 # -- prj_projekte_id ---------------------------------- 6840 # 6841 + "'" + str( self.filter__prj_projekte_id ) + "'" 6842 # 6843 # -- ps_gefszenario_id ---------------------------------- 6844 # 6845 + ", '" + str( self.ps_gefszenario_id ) + "'" 6846 # 6847 # -- logentfernt ------------------------------------------ 6848 # 6849 + ", '" + logentfernt + "'" 6850 # 6851 # -- ps_abk_id ------------------------------------------ 6852 # 6853 + ", '" + str( listeWerte[0] ) + "'" 6854 # 6855 # -- spr_uebvar_id_zus 6856 # 6857 + ", '" + str( listeWerte[1] ) + "'" 6858 # 6859 # -- notizen ---------------------------------- 6860 # 6861 + ", '" + unicode( listeWerte[2] ) + "']);" )

6862 6863 6864 6865 6866 6867 # 6868 # ------------------------------------------------------------------------------------ 6869 # ------------------------------------------------------------------------------------ 6870 # -- Tabelle >prj.pl_psgefanm< schreiben ---------------------------------- 6871 # ------------------------------------------------------------------------------------ 6872 # ------------------------------------------------------------------------------------ 6873 #

6874 - def schreibe__PrjPlPsGefAnm( self, listeWerte, logentfernt = 'false' ):

6875 """ 6876 Methode zum Aktualisieren der projektspezifischen Anmerkungen in der Datenbanktabelle C{prj.pl_psgefanm}. 6877 6878 @param listeWerte: Es sind C{[ps_anmerkung_id, spr_uebvar_id, notizen} zu übergeben 6879 @type listeWerte: Python Liste 6880 6881 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Anmerkung und Gefahrenszenario gelöst werden 6882 @type logentfernt: Zeichenkette, die C{true/false} enthält 6883 """ 6884 6885 # 6886 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 6887 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 6888 # 6889 if( self.ps_gefszenario_id is None ) : 6890 6891 return 6892 6893 6894 6895 6896 # 6897 # -- in Protokolldatei schreiben ------------------------------------------ 6898 # 6899 self.ProtokolldateiEintragen( eintrag = "schreibe__PrjPlPsGefAnm()" 6900 , istKopfzeile = True ) 6901 6902 6903 6904 # 6905 # -- 6906 # -- Projektspezifische Zeilen einlesen ---------------------------------- 6907 # -- ---------- 6908 # -- ---------- 6909 # -- prj.nimm__tabwerte( 'pl_psgefanm', ARRAY[ ---------- 6910 # -- 1. prj_projekte_id ---------- 6911 # -- 2. ps_gefszenario_id ---------- 6912 # -- 3. logentfernt ---------- 6913 # -- 4. ps_anmerkung_id ---------- 6914 # -- 5. spr_uebvar_id ---------- 6915 # -- 6. notizen ---------- 6916 # -- 7. ... ] ) ---------- 6917 # -- ---------- 6918 # -- Momentan wird nicht geprüft, ob die aktuell einzulesende ---------- 6919 # -- projektspezifische Zeile in der Datenbank die aktuell gül- ---------- 6920 # -- tige Zeile ist (einfacherer Algorithmus). Das kann später ---------- 6921 # -- verbessert werden. ---------- 6922 # -- ---------- 6923 # -- ---------- 6924 # -- -------------------------------------------------------------------------- 6925 # 6926 self.__dbAbfrage__( """ 6927 SELECT prj.nimm__tabwerte( 'pl_psgefanm', ARRAY[""" 6928 # 6929 # -- prj_projekte_id ------------------------------------------ 6930 # 6931 + "'" + str( self.filter__prj_projekte_id ) + "'" 6932 # 6933 # -- ps_gefszenario_id ------------------------------------------ 6934 # 6935 + ", '" + str( self.ps_gefszenario_id ) + "'" 6936 # 6937 # -- logentfernt -------------------------------------------------- 6938 # 6939 + ", '" + logentfernt + "'" 6940 # 6941 # -- ps_anmerkung_id 6942 # 6943 + ", '" + str( listeWerte[0] ) + "'" 6944 # 6945 # -- spr_uebvar_id 6946 # 6947 + ", '" + str( listeWerte[1] ) + "'" 6948 # 6949 # -- notizen ------------------------------------------ 6950 # 6951 + ", '" + listeWerte[2].encode('utf-8') + "']);" )

6952 6953 6954 6955 6956 # 6957 # ------------------------------------------------------------------------------------ 6958 # -- Tabelle >prj.pl_psgefstrkt< schreiben ---------------------------------- 6959 # ------------------------------------------------------------------------------------ 6960 #

6961 - def schreibe__PrjPlPsGefStrkt( self, listeWerte, logentfernt = 'false' ):

6962 """ 6963 Methode zum Einfügen / Aktualisieren der (projektspezifischen) Informationen in die Datenbanktabellen C{prj.pl_psgefstrkt}. 6964 6965 @param listeWerte: Es sind C{[str_strkt_id, notizen]} zu übergeben 6966 @type listeWerte: Python Liste 6967 6968 @param logentfernt: Wird C{true} angegeben, soll die Verbindung zwischen Sicherheitsanfordeurng und Dokument gelöst werden 6969 @type logentfernt: Zeichenkette, die C{true/false} enthält 6970 """ 6971 6972 # 6973 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 6974 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 6975 # 6976 if( self.ps_gefszenario_id is None ) : 6977 6978 return 6979 6980 6981 6982 # 6983 # -- in Protokolldatei schreiben ------------------------------------------ 6984 # 6985 self.ProtokolldateiEintragen( eintrag = "schreibe__PrjPlPsGefStrkt()" 6986 , istKopfzeile = True ) 6987 6988 6989 6990 # 6991 # -- 6992 # -- Projektspezifische Zeilen einlesen ---------------------------------- 6993 # -- ---------- 6994 # -- ---------- 6995 # -- prj.nimm__tabwerte( 'pl_psgefstrkt', ARRAY[ ---------- 6996 # -- 1. prj_projekte_id ---------- 6997 # -- 2. ps_gefszenario_id ---------- 6998 # -- 3. str_strkt_id ---------- 6999 # -- 4. notizen ---------- 7000 # -- 5. logentfernt ---------- 7001 # -- 6. ... ] ) ---------- 7002 # -- ---------- 7003 # -- ---------- 7004 # -- Momentan wird nicht geprüft, ob die aktuell einzulesende ---------- 7005 # -- projektspezifische Zeile in der Datenbank die aktuell gül- ---------- 7006 # -- tige Zeile ist (einfacherer Algorithmus). Das kann später ---------- 7007 # -- verbessert werden. ---------- 7008 # -- ---------- 7009 # -- ---------- 7010 # -- -------------------------------------------------------------------------- 7011 # 7012 self.__dbAbfrage__( """ 7013 SELECT prj.nimm__tabwerte( 'pl_psgefstrkt', ARRAY[""" 7014 # 7015 # -- prj_projekte_id ---------------------------------- 7016 # 7017 + "'" + str( self.filter__prj_projekte_id ) + "'" 7018 # 7019 # -- ps_gefszenario_id ---------------------------------- 7020 # 7021 + ", '" + str( self.ps_gefszenario_id ) + "'" 7022 # 7023 # -- str_strkt_id ------------------------------------------ 7024 # 7025 + ", '" + str( listeWerte[0] ) + "'" 7026 # 7027 # -- notizen ------------------------------------------ 7028 # 7029 + ", '" + listeWerte[1].encode('utf-8') + "'" 7030 # 7031 # -- logentfernt ------------------------------------------ 7032 # 7033 + ", '" + logentfernt + "']);" )

7034 7035 7036 7037 7038 # 7039 # ------------------------------------------------------------------------------------ 7040 # -- Tabelle >ps.gefszenario< -------------------------- 7041 # -- >prj.pp_psgefszenario< schreiben -------------------------- 7042 # ------------------------------------------------------------------------------------ 7043 #

7044 - def schreibe__PrjPpPsGefszenario( self, listeGefszen, spr_uebvar_id_reprgefszen ):

7045 """ 7046 Methode zum Einfügen / Aktualisieren der (projektspezifischen) Informationen in die Datenbanktabellen C{ps.gefszenario / prj.pp_psgefszenario}. 7047 7048 7049 @param listeGefszen: Es ist das GUI-Element zu übergeben, welches das Gefahrenszenario einschließlich interner Notizen repräsentiert. 7050 @type listeGefszen: TextCtrlSpWTitel 7051 7052 @param spr_uebvar_id_reprgefszen: Es ist das GUI-Element zu übergeben, welches das repräsentative Gefahrenszenario repräsentiert. 7053 @type spr_uebvar_id_reprgefszen: TextCtrlErg 7054 """ 7055 7056 # 7057 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 7058 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 7059 # 7060 if( self.ps_gefszenario_id is None ) : 7061 7062 return 7063 7064 7065 7066 # 7067 # -- in Protokolldatei schreiben ------------------------------------------ 7068 # 7069 self.ProtokolldateiEintragen( eintrag = "schreibe__PrjPpPsGefszenario()" 7070 , istKopfzeile = True ) 7071 7072 7073 7074 # 7075 # -- 7076 # -- Projektspezifische Zeilen einlesen ---------------------------------- 7077 # -- ---------- 7078 # -- ---------- 7079 # -- intern.nimm__zeile( 'prj.pp_psgefszenario', ARRAY[ ---------- 7080 # -- 'id' ---------- 7081 # -- , 'notizen' ---------- 7082 # -- , 'prj_personen_id' ---------- 7083 # -- , 'prj_projekte_id' ---------- 7084 # -- , 'ps_gefszenario_id' ---------- 7085 # -- , 'spr_uebvar_id' ---------- 7086 # -- , 'spr_uebvar_id_reprgefszen' ---------- 7087 # -- , 'spr_uebvar_id_ursp' ---------- 7088 # -- ], ARRAY[...] ) ---------- 7089 # -- ---------- 7090 # -- Es werden die bisher bestehenden projektspezifischen Zeilen ---------- 7091 # -- überschrieben. ---------- 7092 # -- ---------- 7093 # -- ---------- 7094 # -- -------------------------------------------------------------------------- 7095 # 7096 self.__dbAbfrage__( """ 7097 SELECT intern.nimm__zeile( 'prj.pp_psgefszenario', ARRAY[ 7098 'id' 7099 , 'notizen' 7100 , 'prj_personen_id' 7101 , 'prj_projekte_id' 7102 , 'ps_gefszenario_id' 7103 , 'spr_uebvar_id' 7104 , 'spr_uebvar_id_reprgefszen' 7105 , 'spr_uebvar_id_ursp' 7106 ], ARRAY['""" 7107 + str( listeGefszen[2] ) + """', '""" 7108 + listeGefszen[1].encode('utf-8') + """', '""" 7109 + '0' + """', '""" 7110 + str( self.filter__prj_projekte_id ) + """', '""" 7111 + str( self.ps_gefszenario_id ) + """', '""" 7112 + str( listeGefszen[0] ) + """', '""" 7113 + str( spr_uebvar_id_reprgefszen ) + """', '""" 7114 # 7115 # -- spr_uebvar_id_ursp ---------- 7116 # 7117 + str( listeGefszen[3] ) + """']);""" )

7118 7119 7120 7121 7122 7123 # 7124 # ------------------------------------------------------------------------------------ 7125 # -- Zugeordnete Dokumente selektieren ---------------------------------- 7126 # -- Sicht >prj.zeige__dokdoku< selektieren ---------------------------------- 7127 # ------------------------------------------------------------------------------------ 7128 #

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

7130 """ 7131 Methode zum Herstellen der projektspezifischen Verbindung zwischen Protokolleintrag und Strukturpunkt. 7132 7133 @param prjProjekteId: Es ist die Datenbankidentifikationsnummer (C{prj.projekte.id}) des Projektes zu übergeben. 7134 @type prjProjekteId: Ganzzahl 7135 7136 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des aktuellen Protokolleintrages (Sicherheitsanforderung, Terminplaneintrag) zu übergeben. 7137 @type prtProtokollId: Ganzzahl 7138 7139 @param strStrktId : Es ist die Struktur-Id C{str.strkt.id} zu übergeben. 7140 @type strStrktId : C{Ganzzahl} 7141 7142 @param notizen -- Noch nicht implementiert -- : Es sind die Notizen zu übergeben. 7143 @type notizen : C{Zeichenkette} 7144 7145 @param prjPPrtStrstrktId: Wenn der Protokolleintrag vom Strukturpunkt getrennt werden soll, ist die Datenbankidentifikationsnummer (C{prj.p_prtstrstrkt.id}) der Verbindung übergeben. 7146 @type prjPPrtStrstrktId: Ganzzahl 7147 """ 7148 7149 # 7150 # -- in Protokolldatei schreiben ------------------------------------------ 7151 # 7152 self.ProtokolldateiEintragen( eintrag = "schreibe__psPrtStrkt()" 7153 , istKopfzeile = True ) 7154 7155 7156 7157 # 7158 # -- 7159 # -- Protokolleintrag und Strukturpunkt trennen -------------------------- 7160 # -- >prj.p_prtstrstrkt< ---------- 7161 # -- ---------- 7162 # -- ---------- 7163 # -- SELECT intern.loesche__zeile( 'prj.p_prtstrstrkt' ---------- 7164 # -- , 'prj.p_prtstrstrkt.id = xxx' ---------- 7165 # -- , 'true' ); ---------- 7166 # -- ---------- 7167 # -- ---------- 7168 # -- -------------------------------------------------------------------------- 7169 # 7170 if( prjPPrtStrstrktId is not None ): 7171 7172 self.__dbAbfrage__( """ 7173 SELECT intern.loesche__zeile( 'prj.p_prtstrstrkt', 'prj.p_prtstrstrkt.id = """ 7174 + str( prjPPrtStrstrktId ) 7175 + """', 'true' );""" ) 7176 7177 7178 # 7179 # -- 7180 # -- Protokolleintrag und Strukturpunkt verbinden -------------------------- 7181 # -- >prj.p_prtstrstrkt< ---------- 7182 # -- ---------- 7183 # -- ---------- 7184 # -- prj.nimm__tabwerte( 'p_prtstrstrkt', ARRAY[ ---------- 7185 # -- 1. prj_projekte_id ---------- 7186 # -- 2. prt_protokoll_id ---------- 7187 # -- 3. str_strkt_id ---------- 7188 # -- 4. notizen ---------- 7189 # -- ---------- 7190 # -- ---------- 7191 # -- -------------------------------------------------------------------------- 7192 # 7193 else : 7194 7195 # 7196 # -- Verbindung herstellen ------------------------------------------ 7197 # 7198 self.__dbAbfrage__( """ 7199 SELECT prj.nimm__tabwerte( 'p_prtstrstrkt', ARRAY[""" 7200 # 7201 # -- prj_projekte_id ---------------------------------- 7202 # 7203 + "'" + str( prjProjekteId ) + "'" 7204 # 7205 # -- prt_protokoll_id ---------------------------------- 7206 # 7207 + ", '" + str( prtProtokollId ) + "'" 7208 # 7209 # -- str_strkt_id ------------------------------------------ 7210 # 7211 + ", '" + str( strStrktId ) + "']);" )

7212 7213 7214 7215 7216 # 7217 # ------------------------------------------------------------------------------------ 7218 # -- In Tabelle >prj.p_strverbindung< schreiben -------------------------- 7219 # ------------------------------------------------------------------------------------ 7220 #

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

7222 """ 7223 Methode zum Einfügen / Aktualisieren projektspezifischer Informationen in die / der Datenbanktabelle C{prj.pp_strstrkt}. 7224 7225 @param prjProjekteId : Es ist die Projekt-Id C{prj.projekte.id} zu übergeben. 7226 @type prjProjekteId : C{Ganzzahl} 7227 7228 @param strStrktIdVorg : Es ist die Struktur-Id C{str.strkt.id} des ersten (linken) Strukturpunktes zu übergeben. 7229 @type strStrktIdVorg : C{Ganzzahl} 7230 7231 @param strStrktIdNachf : Es ist die Struktur-Id C{str.strkt.id} des nachfolgenden (mit dem linken verbndenen) Strukturpunkt zu übergeben. 7232 @type strStrktIdNachf : C{Ganzzahl} 7233 7234 @param fbtor : -- Noch nicht implementiert -- : Es ist das Fehlerbaumtor zu übergeben 7235 @type fbtor : C{Zeichenkette} 7236 7237 @param notizen : -- Noch nicht implementiert -- : Es sind die Notizen zu übergeben. 7238 @type notizen : C{Zeichenkette} 7239 """ 7240 7241 # 7242 # -- in Protokolldatei schreiben ------------------------------------------ 7243 # 7244 self.ProtokolldateiEintragen( eintrag = "schreibe__prjPStrverbindung()" 7245 , istKopfzeile = True ) 7246 7247 7248 7249 # 7250 # -- 7251 # -- Verbindung zwischen den Strukturpunkten herstellen ------------------ 7252 # -- ---------- 7253 # -- prj.nimm__tabwerte( 'p_strverbindung', ARRAY[ ---------- 7254 # -- 1. prj_projekte_id ---------- 7255 # -- 2. str_strkt_id_vorg ---------- 7256 # -- 3. str_strkt_id_nachf ---------- 7257 # -- 4. fbtor ---------- 7258 # -- 5. notizen ] ) ---------- 7259 # -- ---------- 7260 # -- -------------------------------------------------------------------------- 7261 # 7262 self.__dbAbfrage__( """ 7263 SELECT * FROM prj.nimm__tabwerte( 'p_strverbindung', ARRAY[""" 7264 # 7265 # -- prj_projekte_id ---------------------------------- 7266 # 7267 + "'" + str( prjProjekteId ) + "'" 7268 # 7269 # -- str_strkt_id_vorg ---------------------------------- 7270 # 7271 + ", '" + str( strStrktIdVorg ) + "'" 7272 # 7273 # -- str_strkt_id_nachf ---------------------------------- 7274 # 7275 + ", '" + str( strStrktIdNachf ) + "']);" )

7276 7277 7278 7279 7280 # 7281 # ------------------------------------------------------------------------------------ 7282 # -- In Tabelle >prt.protokoll< schreiben ---------------------------------- 7283 # ------------------------------------------------------------------------------------ 7284 #

7285 - def schreibe__PrtProtokoll( self, prtTypId, notizen = zk.gibZk( "" ) ):

7286 """ 7287 Methode zum Einfügen / Aktualisieren der Informationen in die / der Datenbanktabelle C{prt.protokoll}. 7288 7289 @param prtTypId : Es ist die Projekt-Id C{prt.typ.id} zu übergeben. 7290 @type prtTypId : C{Ganzzahl} 7291 7292 @param notizen : Es sind die Notizen zu übergeben. 7293 @type notizen : C{Zeichenkette} 7294 """ 7295 7296 # 7297 # -- in Protokolldatei schreiben ------------------------------------------ 7298 # 7299 self.ProtokolldateiEintragen( eintrag = "schreibe__PrtProtokoll()" 7300 , istKopfzeile = True ) 7301 7302 7303 7304 # 7305 # -- 7306 # -- Protokolleintrag anlegen ------------------------------------------ 7307 # -- >prt.protokoll< ------------------ 7308 # -- ------------------ 7309 # -- ------------------ 7310 # -- intern.nimm__zeile( 'prt.protokoll', ARRAY[ ------------------ 7311 # -- 'id' ------------------ 7312 # -- , 'prt_typ_id' ------------------ 7313 # -- , 'notizen' ------------------ 7314 # -- ], ARRAY[...] ) ------------------ 7315 # -- ------------------ 7316 # -- ------------------ 7317 # -- -------------------------------------------------------------------------- 7318 # 7319 self.__dbAbfrage__( """ 7320 SELECT intern.nimm__zeile( 'prt.protokoll', ARRAY[ 'id', 'prt_typ_id', 'notizen' ], ARRAY[ """ 7321 # 7322 # -- id ------------------------------------------ 7323 # 7324 + "CAST( intern.gib__naechsteid( 'prt.protokoll' ) AS varchar )" 7325 # 7326 # -- prt_typ_id ------------------------------------------ 7327 # 7328 + ", '" + str( prtTypId ) + "'" 7329 # 7330 # -- notizen ------------------------------------------ 7331 # 7332 + ", '" + notizen.encode('utf-8') + "']);" ) 7333 7334 7335 # 7336 # -- >spr.uebvar.id< zurückgeben ------------------------------------------ 7337 # 7338 return self.__gibWert__( 0, 0 )

7339 7340 7341 7342 7343 7344 # 7345 # ------------------------------------------------------------------------------------ 7346 # -- Wortgruppe übernehmen -------------------------------------------------- 7347 # ------------------------------------------------------------------------------------ 7348 #

7349 - def schreibe__sprNimmWgruppe( self, sprUebvarId, wortgruppe = zk.gibZk( "" ), sprSprachenId = 1 ):

7350 """ 7351 Methode zum Schreiben von Wortgruppen. 7352 7353 7354 @param sprUebvarId : Es ist die Datenbankidentifikationsnummer (C{spr.uebvar.id}) der Übersetzungsvariante zu übergeben, der die aktuelle C{wortgruppe} als Übersetzung hinzugefügt werden soll. 7355 @type sprUebvarId : C{Ganzzahl} 7356 7357 @param wortgruppe: Es ist die Wortgruppe anzugeben. 7358 @type wortgruppe: Zeichenkette 7359 7360 @param sprSprachenId: Es ist die Datenbankidentifikationsnummer (C{spr.sprachen.id}) der Sprache zu übergeben in der die C{wortgruppe} vorliegt. 7361 @type sprSprachenId: Ganzzahl 7362 7363 @return: Es wird die C{spr.uebvar.id} der eingelesenen Wortgruppe zurückgegeben. 7364 @rtype: Ganzzahl 7365 """ 7366 7367 # 7368 # -- in Protokolldatei schreiben ------------------------------------------ 7369 # 7370 self.ProtokolldateiEintragen( eintrag = "schreibe__sprNimmWgruppe()" 7371 , istKopfzeile = True ) 7372 7373 7374 7375 # 7376 # -- SQL-Abfrage ausführen -------------------------------------------------- 7377 # 7378 self.__dbAbfrage__( """ 7379 -- 7380 -- Wortgruppe übernehmen 7381 -- 7382 SELECT spr.nimm__wgruppe( '""" + wortgruppe.encode('utf-8') + """' 7383 , '""" + str( sprSprachenId ) + """' 7384 , '""" + str( sprUebvarId ) + """' ) 7385 ;""" ) 7386 7387 7388 # 7389 # -- >spr.uebvar.id< zurückgeben ------------------------------------------ 7390 # 7391 return self.__gibWert__( 0, 0 )

7392 7393 7394 7395 7396 7397 # 7398 # ------------------------------------------------------------------------------------ 7399 # ------------------------------------------------------------------------------------ 7400 # -- Übersetzungsvariante übernehmen ---------------------------------- 7401 # ------------------------------------------------------------------------------------ 7402 # ------------------------------------------------------------------------------------ 7403 #

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

7405 """ 7406 Methode zum Schreiben von Übersetzungsvarianten. 7407 7408 7409 @param ListBoxErg: Es ist die C{ListBoxErg} zu übergeben, die die zu schreibenden Übersetzungen enthält. 7410 @type ListBoxErg: ListBoxErg 7411 7412 @param sprUebvarId : Es ist die Datenbankidentifikationsnummer (C{spr.uebvar.id}) der Übersetzungsvariante zu übergeben. 7413 @type sprUebvarId : C{Ganzzahl} 7414 7415 @param istMehrfachVerw: Die Übersetzungsvariante (C{spr.uebvar.id}) wird mehrfach verwendet. 7416 @type istMehrfachVerw: Boolean 7417 7418 @return: Es wird die ggf. neu erzeugte spr.uebvar.id zurückgegeben. 7419 @rtype: Ganzzahl 7420 """ 7421 7422 # 7423 # -- in Protokolldatei schreiben ------------------------------------------ 7424 # 7425 self.ProtokolldateiEintragen( eintrag = "schreibe__sprUebvar()" 7426 , istKopfzeile = True ) 7427 7428 7429 7430 # 7431 # -- Hilfsübersetzung einfügen ------------------------------------------ 7432 # -- ---------- 7433 # -- Es wird zur >spr.uebvar.id == spr_uebvar_id__akt< in der ---------- 7434 # -- Sprache >spr.sprachen.id == 0 < (die nicht in der Projekt- ---------- 7435 # -- arbeit verwendet werden soll) eine Hilfsübersetzung ---------- 7436 # -- eingefügt ---------- 7437 # -- ---------- 7438 # -- ---------- 7439 # -- -------------------------------------------------------------------------- 7440 # 7441 spr_uebvar_id__akt = sprUebvarId 7442 7443 if( istMehrfachVerw ) : 7444 7445 spr_uebvar_id__akt = self.schreibe__sprNimmWgruppe( sprUebvarId = 0 7446 , wortgruppe = 'beliebige Zeichenkette' 7447 , sprSprachenId = 0 ) 7448 7449 else : 7450 7451 self.schreibe__sprNimmWgruppe( sprUebvarId = spr_uebvar_id__akt 7452 , wortgruppe = 'beliebige Zeichenkette' 7453 , sprSprachenId = 0 ) 7454 7455 7456 7457 # 7458 # -- Keine Mehrfachverwendung der Übersetzungsvariante ------------------ 7459 # -- ---------- 7460 # -- Die aktuellen Übersetzungen innerhalb der zu korrigierenden ---------- 7461 # -- Übersetzungsvariante löschen (somit läßt sich leicht mittels ---------- 7462 # -- >spr.nimm__wgruppe(...)< die Korrektur durchführen ---------- 7463 # -- ---------- 7464 # -- ---------- 7465 # -- -------------------------------------------------------------------------- 7466 # 7467 if( not istMehrfachVerw ) : 7468 7469 self.__dbAbfrage__( """ 7470 -- 7471 -- Alle Übersetzungen löschen 7472 -- 7473 SELECT intern.loesche__zeile( 'spr.uebersetzung' 7474 , 'spr.uebersetzung.spr_uebvar_id = """ + str( spr_uebvar_id__akt ) + """ 7475 AND spr_sprachen_id > 0' 7476 , 'true' );""" ) 7477 7478 7479 7480 # 7481 # -- Übersetzungsvarianten einlesen ------------------------------------------ 7482 # -- ---------- 7483 # -- ---------- 7484 # -- -------------------------------------------------------------------------- 7485 # 7486 for i in range( ListBoxErg.GetCount() ) : 7487 7488 self.schreibe__sprNimmWgruppe( sprUebvarId = spr_uebvar_id__akt 7489 , wortgruppe = ListBoxErg.gibWert( i ) 7490 , sprSprachenId = ListBoxErg.gibClientData( i )[0] ) 7491 7492 7493 7494 # 7495 # -- Hilfsübersetzung entfernen ------------------------------------------ 7496 # -- ---------- 7497 # -- ---------- 7498 # -- -------------------------------------------------------------------------- 7499 # 7500 self.__dbAbfrage__( """ 7501 -- 7502 -- Hilfsübersetzung löschen 7503 -- 7504 SELECT intern.loesche__zeile( 'spr.uebersetzung' 7505 , 'spr.uebersetzung.spr_uebvar_id = """ + str( spr_uebvar_id__akt ) + """ 7506 AND spr_sprachen_id = 0' 7507 , 'true' );""" ) 7508 7509 7510 7511 # 7512 # -- aktuelle >spr.uebvar.id< zurückgeben ---------------------------------- 7513 # 7514 return spr_uebvar_id__akt

7515 7516 7517 7518 # 7519 # ------------------------------------------------------------------------------------ 7520 # ------------------------------------------------------------------------------------ 7521 # -- In der Datenbank verfügbare Dokumente selektieren ------------------ 7522 # ------------------------------------------------------------------------------------ 7523 # ------------------------------------------------------------------------------------ 7524 #

7525 - def selektiere__dokDoku( self, TreeCtrlErg_ListBoxErg, internFirmaId = None, dokDokuId = None, ignorierePsGefszenarioId = False ):

7526 """ 7527 Methode zur Darstellung der in der Datenbank verfügbaren Dokumente. 7528 7529 @note: Die übergebene Liste (C{TreeCtrlErg_ListBoxErg}) wird verändert ! 7530 7531 @param TreeCtrlErg_ListBoxErg: Es ist die Auswahlliste zu übergeben, die die Dokumente aufnimmt. 7532 @type TreeCtrlErg_ListBoxErg: TreeCtrlErg oder ListBoxErg 7533 7534 @param internFirmaId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 7535 @type internFirmaId: Ganzzahl 7536 7537 @param dokDokuId: Es ist die Datenbankidentifikationsnummer (C{dok.doku.id}) des Dokumentes zu übergeben. 7538 @type dokDokuId: Ganzzahl 7539 7540 @return: Es wird das Ergebnis der Datenbankabfrage zurückgegeben, wenn C{ListBoxErg = None}. Sonst wird C{None} zurückgegeben. 7541 @rtype: Liste 7542 7543 @param ignorierePsGefszenarioId: Es ist die C{True} anzugeben, wenn C{self.ps_gefszenario_id} in der SQL-Abfrage berücksichtigt werden soll. 7544 @type ignorierePsGefszenarioId: Boolean 7545 """ 7546 7547 # 7548 # -- in Protokolldatei schreiben ------------------------------------------ 7549 # 7550 # 7551 # fortsetzen 7552 # 7553 # print "selektiere__dokDoku()" 7554 7555 self.ProtokolldateiEintragen( eintrag = "selektiere__dokDoku()" 7556 , istKopfzeile = True ) 7557 7558 7559 7560 # 7561 # -- SQL-Abfrage ausführen -------------------------------------------------- 7562 # 7563 self.__dbAbfrage__( self.__gibSQL_prjPrtDoku__( prjProjekteId = None 7564 , sprSprachenId = self.filter__spr_sprachen_id 7565 , prtProtokollId = None 7566 , internFirmaId = internFirmaId 7567 , dokDokuId = dokDokuId 7568 , ignorierePsGefszenarioId = ignorierePsGefszenarioId ) ) 7569 7570 7571 7572 # 7573 # -- es sind keine Dokumente darzustellen ---------------------------------- 7574 # 7575 if( self.__gibAnzZeilen__() == 0 ) : return 7576 7577 7578 7579 # 7580 # -- >TreeCtrlErg< oder >ListBoxErg< ---------------------------------- 7581 # 7582 istTreeCtrlErg = ( str( TreeCtrlErg_ListBoxErg ).find( "wxPyTreeCtrl" ) >= 0 ) 7583 if( TreeCtrlErg_ListBoxErg is None ) : istTreeCtrlErg = None 7584 7585 7586 # 7587 # -- Hauptknoten übernehmen -------------------------------------------------- 7588 # -- (nur TreeCtrlErg) -------------------------------------------------- 7589 # 7590 if( istTreeCtrlErg ) : 7591 7592 TreeCtrlErg_ListBoxErg.nimmHauptknoten( wert = HK_DOK, bezHK = HK_DOK ) 7593 7594 7595 7596 # 7597 # -- Dokumente übernehmen -------------------------------------------------- 7598 # 7599 erg = [] 7600 for i in range( self.__gibAnzZeilen__() ): 7601 7602 # 7603 # -- Dokumentinformationen ------------------------------------------ 7604 # 7605 aspekt = ' B:' 7606 rev = '---' 7607 datum = '---' 7608 doknr = '---' 7609 if( self.__gibWert__( i, 8 ) == 'QUELLE' ) : aspekt = ' Q:' 7610 if( len( self.__gibWert__( i, 5 ) ) > 0 ) : rev = self.__gibWert__( i, 5 ) 7611 if( len( str( self.__gibWert__( i, 6 ) ) ) > 0 ) : datum = zk.gibDatum( self.__gibWert__( i, 6 ) ) 7612 if( len( self.__gibWert__( i, 2 ) ) > 0 ) : doknr = self.__gibWert__( i, 2 ) 7613 7614 dokinfo = ( self.__gibWert__( i, 3 ) 7615 + '\t>' + self.__gibWert__( i, 9 ) 7616 + '<\n( Dok-Nr: ' + doknr 7617 + '\tDatum: ' + str( datum ) 7618 + '\tRev: ' + rev 7619 + ' )' ) 7620 7621 7622 # 7623 # -- Notizen -------------------------------------------------- 7624 # 7625 notizen = ( self.__gibWert__( i, 1 ) 7626 + '\n' + self.__gibWert__( i, 4 ) ) 7627 7628 7629 # 7630 # -- clientData -------------------------------------------------- 7631 # 7632 # -- [0] prj.pl_prtdokdoku.notizen ------------------ 7633 # -- [1] prj.pl_prtdokdoku.nr ------------------ 7634 # -- [2] prj.pl_prtdokdoku.spr_uebvar_id ------------------ 7635 # -- [3] prj.pl_prtdokdoku.spr_uebvar_id_zus ------------------ 7636 # -- ------------------ 7637 # -- [4] prj.pl_dokausgabe.notizen ------------------ 7638 # -- [5] prj.pl_dokausgabe.datum ------------------ 7639 # -- [6] prj.pl_dokausgabe.istfrei ------------------ 7640 # -- [7] prj.pl_dokausgabe.stand ------------------ 7641 # -- ------------------ 7642 # -- [8] dok__doku__aspekt ------------------ 7643 # -- [9] prj.zeige__dokdoku.dok__doku__id ------------------ 7644 # -- [10] titel (prj.pl_prtdokdoku.spr_uebvar_id) ------------------ 7645 # -- [11] zus (prj.pl_prtdokdoku.spr_uebvar_id_zus) ------------------ 7646 # -- [12] prj__pl_prtdokdoku__prt_protokoll_id ------------------ 7647 # -- [13] dok__doku__spr_uebvar_id_kb ------------------ 7648 # -- [14] dok__doku__intern_firma_id ------------------ 7649 # 7650 clientData = [ self.__gibWert__( i, 4 ) 7651 , self.__gibWert__( i, 2 ) 7652 , self.__gibWert__( i, 10 ) 7653 , self.__gibWert__( i, 11 ) 7654 , self.__gibWert__( i, 7 ) 7655 , self.__gibWert__( i, 6 ) 7656 , self.__gibWert__( i, 12 ) 7657 , self.__gibWert__( i, 5 ) 7658 , self.__gibWert__( i, 8 ) 7659 , self.__gibWert__( i, 0 ) 7660 , self.__gibWert__( i, 3 ) 7661 , self.__gibWert__( i, 9 ) 7662 , self.__gibWert__( i, 13 ) 7663 , self.__gibWert__( i, 14 ) 7664 , self.__gibWert__( i, 15 ) ] 7665 7666 7667 # 7668 # -- Dokumente übernehmen ------------------------------------------ 7669 # 7670 if( istTreeCtrlErg ) : 7671 7672 TreeCtrlErg_ListBoxErg.nimmWert( wert = zk.gibIdWertNotizen( id = self.__gibWert__( i, 0 ) 7673 , zusInfo = aspekt 7674 , wert = dokinfo 7675 , notizen = notizen ) 7676 , wertId = None 7677 , dbId = self.__gibWert__( i, 0 ) 7678 , wertIdVorgaenger = '' 7679 , clientData = clientData ) 7680 7681 elif( not istTreeCtrlErg 7682 and istTreeCtrlErg is not None ) : 7683 7684 TreeCtrlErg_ListBoxErg.nimmWert( wert = zk.gibIdWertNotizen( id = self.__gibWert__( i, 0 ) 7685 , zusInfo = aspekt 7686 , wert = dokinfo 7687 , notizen = notizen ) 7688 , clientData = clientData ) 7689 7690 elif( istTreeCtrlErg is None ) : 7691 7692 erg.append( clientData ) 7693 7694 7695 # 7696 # -- Liste zurückgeben ------------------------------------------ 7697 # 7698 return erg

7699 7700 7701 7702 7703 7704 7705 7706 # 7707 # ------------------------------------------------------------------------------------ 7708 # ------------------------------------------------------------------------------------ 7709 # -- In der Datenbank verfügbare, projektbezogene Dokumente selektieren -- 7710 # ------------------------------------------------------------------------------------ 7711 # ------------------------------------------------------------------------------------ 7712 #

7713 - def selektiere__dokDoku__Projekt__Sprache( self, TreeCtrlErg_ListBoxErg, internFirmaId = None, dokDokuId = None ):

7714 """ 7715 Methode zur Darstellung der in der Datenbank verfügbaren projektbezogenen Dokumente. 7716 7717 @note: Die übergebene Liste (C{TreeCtrlErg_ListBoxErg}) wird verändert ! 7718 7719 @param TreeCtrlErg_ListBoxErg: Es ist die Auswahlliste zu übergeben, die die Dokumente aufnimmt. 7720 @type TreeCtrlErg_ListBoxErg: TreeCtrlErg oder ListBoxErg 7721 7722 @param internFirmaId: Es ist die Datenbankidentifikationsnummer (C{intern.firma.id}) des Erstellers des aktuellen Dokumentes zu übergeben. 7723 @type internFirmaId: list (Ganzzahl) 7724 7725 @param dokDokuId: Es ist die Datenbankidentifikationsnummer (C{dok.doku.id}) des Dokumentes zu übergeben. 7726 @type dokDokuId: list (Ganzzahl) 7727 """ 7728 7729 # 7730 # -- es sind keine Dokumente darzustellen ---------------------------------- 7731 # 7732 if( len( self.daten__dokDoku__Projekt__Sprache ) == 0 ) : return 7733 7734 7735 7736 # 7737 # -- >TreeCtrlErg< oder >ListBoxErg< ---------------------------------- 7738 # 7739 istTreeCtrlErg = ( str( TreeCtrlErg_ListBoxErg ).find( "wxPyTreeCtrl" ) >= 0 ) 7740 if( TreeCtrlErg_ListBoxErg is None ) : istTreeCtrlErg = None 7741 7742 7743 7744 # 7745 # -- Hauptknoten übernehmen -------------------------------------------------- 7746 # -- (nur TreeCtrlErg) -------------------------------------------------- 7747 # 7748 if( istTreeCtrlErg ) : 7749 7750 TreeCtrlErg_ListBoxErg.nimmHauptknoten( wert = HK_DOK, bezHK = HK_DOK ) 7751 7752 7753 7754 # 7755 # -- Dokumente übernehmen -------------------------------------------------- 7756 # 7757 erg = [] 7758 for i in range( len( self.daten__dokDoku__Projekt__Sprache ) ): 7759 7760 # 7761 # -- nach Firma selektieren ------------------------------------------ 7762 # 7763 if( internFirmaId is not None 7764 and self.daten__dokDoku__Projekt__Sprache[i][15] not in internFirmaId ) : 7765 7766 continue 7767 7768 7769 # 7770 # -- nach Dokumenten-Id selektieren ---------------------------------- 7771 # 7772 if( dokDokuId is not None 7773 and self.daten__dokDoku__Projekt__Sprache[i][0] not in dokDokuId ) : 7774 7775 continue 7776 7777 7778 # 7779 # -- Dokumentinformationen ------------------------------------------ 7780 # 7781 aspekt = ' B:' 7782 rev = '---' 7783 datum = '---' 7784 doknr = '---' 7785 if( self.daten__dokDoku__Projekt__Sprache[i][8] == 'QUELLE' ) : aspekt = ' Q:' 7786 if( len( self.daten__dokDoku__Projekt__Sprache[i][5] ) > 0 ) : rev = self.daten__dokDoku__Projekt__Sprache[i][5] 7787 if( len( str( self.daten__dokDoku__Projekt__Sprache[i][6] ) ) > 0 ) : datum = zk.gibDatum( self.daten__dokDoku__Projekt__Sprache[i][6] ) 7788 if( len( self.daten__dokDoku__Projekt__Sprache[i][2] ) > 0 ) : doknr = self.daten__dokDoku__Projekt__Sprache[i][2] 7789 7790 dokinfo = ( self.daten__dokDoku__Projekt__Sprache[i][3] 7791 + '\t>' + self.daten__dokDoku__Projekt__Sprache[i][9] 7792 + '<\n( Dok-Nr: ' + doknr 7793 + '\tDatum: ' + str( datum ) 7794 + '\tRev: ' + rev 7795 + ' )' ) 7796 7797 7798 # 7799 # -- Notizen -------------------------------------------------- 7800 # 7801 notizen = ( self.daten__dokDoku__Projekt__Sprache[i][1] 7802 + '\n' + self.daten__dokDoku__Projekt__Sprache[i][4] ) 7803 7804 7805 # 7806 # -- clientData -------------------------------------------------- 7807 # 7808 # -- [0] prj.pl_prtdokdoku.notizen ------------------ 7809 # -- [1] prj.pl_prtdokdoku.nr ------------------ 7810 # -- [2] prj.pl_prtdokdoku.spr_uebvar_id ------------------ 7811 # -- [3] prj.pl_prtdokdoku.spr_uebvar_id_zus ------------------ 7812 # -- ------------------ 7813 # -- [4] prj.pl_dokausgabe.notizen ------------------ 7814 # -- [5] prj.pl_dokausgabe.datum ------------------ 7815 # -- [6] prj.pl_dokausgabe.istfrei ------------------ 7816 # -- [7] prj.pl_dokausgabe.stand ------------------ 7817 # -- ------------------ 7818 # -- [8] dok__doku__aspekt ------------------ 7819 # -- [9] prj.zeige__dokdoku.dok__doku__id ------------------ 7820 # -- [10] titel (prj.pl_prtdokdoku.spr_uebvar_id) ------------------ 7821 # -- [11] zus (prj.pl_prtdokdoku.spr_uebvar_id_zus) ------------------ 7822 # -- [12] prj__pl_prtdokdoku__prt_protokoll_id ------------------ 7823 # -- [13] dok__doku__spr_uebvar_id_kb ------------------ 7824 # -- [14] dok__doku__intern_firma_id ------------------ 7825 # 7826 clientData = [ self.daten__dokDoku__Projekt__Sprache[i][4] 7827 , self.daten__dokDoku__Projekt__Sprache[i][2] 7828 , self.daten__dokDoku__Projekt__Sprache[i][10] 7829 , self.daten__dokDoku__Projekt__Sprache[i][11] 7830 , self.daten__dokDoku__Projekt__Sprache[i][7] 7831 , self.daten__dokDoku__Projekt__Sprache[i][6] 7832 , self.daten__dokDoku__Projekt__Sprache[i][12] 7833 , self.daten__dokDoku__Projekt__Sprache[i][5] 7834 , self.daten__dokDoku__Projekt__Sprache[i][8] 7835 , self.daten__dokDoku__Projekt__Sprache[i][0] 7836 , self.daten__dokDoku__Projekt__Sprache[i][3] 7837 , self.daten__dokDoku__Projekt__Sprache[i][9] 7838 , self.daten__dokDoku__Projekt__Sprache[i][13] 7839 , self.daten__dokDoku__Projekt__Sprache[i][14] 7840 , self.daten__dokDoku__Projekt__Sprache[i][15] ] 7841 7842 7843 # 7844 # -- Dokumente übernehmen ------------------------------------------ 7845 # 7846 if( istTreeCtrlErg ) : 7847 7848 TreeCtrlErg_ListBoxErg.nimmWert( wert = zk.gibIdWertNotizen( id = self.daten__dokDoku__Projekt__Sprache[i][0] 7849 , zusInfo = aspekt 7850 , wert = dokinfo 7851 , notizen = notizen ) 7852 , wertId = None 7853 , dbId = self.daten__dokDoku__Projekt__Sprache[i][0] 7854 , wertIdVorgaenger = '' 7855 , clientData = clientData ) 7856 7857 elif( not istTreeCtrlErg 7858 and istTreeCtrlErg is not None ) : 7859 7860 TreeCtrlErg_ListBoxErg.nimmWert( wert = zk.gibIdWertNotizen( id = self.daten__dokDoku__Projekt__Sprache[i][0] 7861 , zusInfo = aspekt 7862 , wert = dokinfo 7863 , notizen = notizen ) 7864 , clientData = clientData ) 7865 7866 elif( istTreeCtrlErg is None ) : 7867 7868 erg.append( clientData ) 7869 7870 7871 # 7872 # -- Liste zurückgeben ------------------------------------------ 7873 # 7874 return erg

7875 7876 7877 7878 7879 7880 7881 7882 # 7883 # ------------------------------------------------------------------------------------ 7884 # ------------------------------------------------------------------------------------ 7885 # -- In der Datenbank verfügbare, projektbezogene Abkürzungen selektieren -- 7886 # ------------------------------------------------------------------------------------ 7887 # ------------------------------------------------------------------------------------ 7888 #

7889 - def selektiere__GefszenId_AbkId__Projekt__Sprache( self, ComboBoxErg_ListBoxSpWTitelAL, ListBoxErg, psAbkTyp ):

7890 """ 7891 Methode zur Darstellung der in der Datenbank verfügbaren projektbezogenen Abkürzungen. 7892 7893 @note: Die übergebene Liste (C{ComboBoxErg_ListBoxSpWTitelAL}) wird verändert ! 7894 7895 @param ComboBoxErg_ListBoxSpWTitelAL: Es ist die Auswahlliste zu übergeben, die die Abkürzungen aufnimmt. 7896 @type ComboBoxErg_ListBoxSpWTitelAL: ComboBoxErg oder ListBoxSpWTitelAL 7897 7898 @param ListBoxErg: Es ist das Texteingabefeld zu übergeben, das die Begründung aufnimmt 7899 @type ListBoxErg: ListBoxErg 7900 7901 @param psAbkTyp: Es ist der Typ C{ps.abk.typ} der Abkürzung anzugeben. 7902 @type psAbkTyp: Zeichenkette 7903 """ 7904 7905 # 7906 # -- >ComboBoxErg< oder >ListBoxSpWTitelAL< ---------------------------------- 7907 # 7908 istComboBoxErg = not ( str( ComboBoxErg_ListBoxSpWTitelAL ).find( "ListBoxSpWTitelAL" ) >= 0 ) 7909 if( ComboBoxErg_ListBoxSpWTitelAL is None ) : istComboBoxErg = None 7910 7911 7912 7913 # 7914 # -- Eingabefelder zurücksetzen ------------------------------------------ 7915 # 7916 if( istComboBoxErg ) : 7917 7918 ComboBoxErg_ListBoxSpWTitelAL.selektiereWert( clientDataId = 0 ) 7919 ListBoxErg.loescheAlles() 7920 7921 else : 7922 7923 ComboBoxErg_ListBoxSpWTitelAL.schiebeAlleRechts() 7924 7925 7926 7927 # 7928 # -- Abkürzungen ---------------------------------------------------------- 7929 # -- -------------------------------------------------- 7930 # -- 1. Gefährdete Personen -------------------------------------------------- 7931 # -- 2. Häufigkeit -------------------------------------------------- 7932 # -- 3. Gefahrenstufe -------------------------------------------------- 7933 # -- 4. Risikostufe -------------------------------------------------- 7934 # -- -------------------------------------------------- 7935 # 7936 daten__GefszenId_AbkId__Projekt__Sprache = None 7937 if( psAbkTyp == 'GP' ) : 7938 7939 daten__GefszenId_AbkId__Projekt__Sprache = self.daten__GefszenId_AbkId_gp__Projekt__Sprache 7940 7941 elif( psAbkTyp == 'RH' ) : 7942 7943 daten__GefszenId_AbkId__Projekt__Sprache = self.daten__GefszenId_AbkId_rh__Projekt__Sprache 7944 7945 elif( psAbkTyp == 'RG' ) : 7946 7947 daten__GefszenId_AbkId__Projekt__Sprache = self.daten__GefszenId_AbkId_rg__Projekt__Sprache 7948 7949 elif( psAbkTyp == 'RR' ) : 7950 7951 daten__GefszenId_AbkId__Projekt__Sprache = self.daten__GefszenId_AbkId_rr__Projekt__Sprache 7952 7953 7954 7955 # 7956 # -- es sind keine Abkürzungen darzustellen ---------------------------------- 7957 # 7958 if( len( daten__GefszenId_AbkId__Projekt__Sprache ) == 0 ) : return 7959 7960 7961 7962 # 7963 # -- Zur Gefahrenszenario-Id sind keine Werte zugeordnet ------------------ 7964 # 7965 if( self.ps_gefszenario_id not in daten__GefszenId_AbkId__Projekt__Sprache ) : 7966 7967 return 7968 7969 7970 7971 # 7972 # -- Abkürzungen übernehmen ---------------------------------- 7973 # 7974 if( istComboBoxErg ) : 7975 7976 ComboBoxErg_ListBoxSpWTitelAL.selektiereWert( 7977 clientDataId = daten__GefszenId_AbkId__Projekt__Sprache[self.ps_gefszenario_id][0][0] ) 7978 7979 ListBoxErg.nimmWert( wert = ( daten__GefszenId_AbkId__Projekt__Sprache[self.ps_gefszenario_id][0][1] 7980 + '\t|\t' 7981 + daten__GefszenId_AbkId__Projekt__Sprache[self.ps_gefszenario_id][0][2] ) 7982 , clientData = [ # -- spr.uebvar.id --------------------- 7983 daten__GefszenId_AbkId__Projekt__Sprache[self.ps_gefszenario_id][0][3] 7984 # -- >notizen< ------------------------- 7985 , daten__GefszenId_AbkId__Projekt__Sprache[self.ps_gefszenario_id][0][2] ] ) 7986 7987 else : 7988 7989 for i in range( len( daten__GefszenId_AbkId__Projekt__Sprache[self.ps_gefszenario_id] ) ): 7990 7991 ComboBoxErg_ListBoxSpWTitelAL.schiebeLinks( daten__GefszenId_AbkId__Projekt__Sprache[self.ps_gefszenario_id][i][0] )

7992 7993 7994 7995 7996 7997 7998 7999 # 8000 # ------------------------------------------------------------------------------------ 8001 # ------------------------------------------------------------------------------------ 8002 # -- In der Datenbank verfügbare, projektübergreifende Anmerkungen ---------- 8003 # -- selektieren ---------- 8004 # ------------------------------------------------------------------------------------ 8005 # ------------------------------------------------------------------------------------ 8006 #

8007 - def selektiere__GefszenId_AnmId( self, ListBoxErg ):

8008 """ 8009 Methode zur Darstellung der in der Datenbank verfügbaren, auf das Gefahrenszenario bezogene projektübergreifende Anmerkungen. 8010 8011 @note: Die übergebene Liste (C{ListBoxErg}) wird verändert ! 8012 8013 @param ListBoxErg: Es ist die Auswahlliste zu übergeben, die die Anmerkungen aufnimmt. 8014 @type ListBoxErg: ListBoxErg 8015 """ 8016 8017 # 8018 # -- Eingabefelde zurücksetzen ------------------------------------------ 8019 # 8020 ListBoxErg.loescheAlles() 8021 8022 8023 8024 # 8025 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 8026 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 8027 # 8028 if( self.ps_gefszenario_id is None ) : 8029 8030 return 8031 8032 8033 8034 # 8035 # -- in Protokolldatei schreiben ------------------------------------------ 8036 # 8037 # 8038 # fortsetzen 8039 # 8040 # print "selektiere__GefszenId_AnmId()" 8041 8042 self.ProtokolldateiEintragen( eintrag = "selektiere__GefszenId_AnmId()" 8043 , istKopfzeile = True ) 8044 8045 8046 8047 # 8048 # -- SQL-Abfrage ausführen -------------------------------------------------- 8049 # 8050 self.__dbAbfrage__( """ 8051 SELECT DISTINCT 8052 -- 0 8053 prj.pl_psgefanm.ps_anmerkung_id 8054 , prj.pl_psgefanm.spr_uebvar_id 8055 -- 2 8056 , spr.zeige__wgruppe.wgruppe AS zk 8057 , prj.pl_psgefanm.notizen 8058 -- für ORDER BY 8059 , prj.pl_psgefanm.ps_gefszenario_id 8060 FROM 8061 prj.zeige__pl_psgefanm_le 8062 , prj.pl_psgefanm 8063 LEFT OUTER JOIN spr.zeige__wgruppe 8064 ON ( 8065 prj.pl_psgefanm.spr_uebvar_id = spr.zeige__wgruppe.spr_uebvar_id 8066 AND 8067 -- 8068 -- Sprache Auswählen 8069 -- 8070 spr.zeige__wgruppe.spr_sprachen_id = """ + str( self.filter__spr_sprachen_id ) + """ 8071 ) 8072 WHERE 8073 -- 8074 -- Ausschließlich die letzten (aktuellen) Anmerkungen anzeigen, ... 8075 -- 8076 prj.zeige__pl_psgefanm_le.prj__pl_psgefanm__id = prj.pl_psgefanm.id 8077 AND 8078 -- 8079 -- ... die nicht entfernt wurden 8080 -- 8081 prj.pl_psgefanm.logentfernt = false 8082 AND 8083 -- 8084 -- Gefahrenszenario auswählen 8085 -- 8086 prj.pl_psgefanm.ps_gefszenario_id = """ + str( self.ps_gefszenario_id ) + """ 8087 ORDER BY 8088 prj.pl_psgefanm.ps_anmerkung_id 8089 , prj.pl_psgefanm.ps_gefszenario_id 8090 ; 8091 """ ) 8092 8093 8094 8095 # 8096 # -- es sind keine Dokumente darzustellen ---------------------------------- 8097 # 8098 if( self.__gibAnzZeilen__() == 0 ) : return 8099 8100 8101 8102 # 8103 # -- Anmerkungen übernehmen ---------------------------------- 8104 # -- (ggf. Gefahrenszenario-Id durchlaufen) ---------------------------------- 8105 # 8106 for i in range( self.__gibAnzZeilen__() ): 8107 8108 ListBoxErg.nimmWert( wert = zk.gibIdWertNotizen( id = self.__gibWert__( i, 0 ) 8109 , zusInfo = "" 8110 , wert = self.__gibWert__( i, 2 ) 8111 , notizen = self.__gibWert__( i, 3 ) ) 8112 , clientData = [ # -- spr.uebvar.id --------------------- 8113 self.__gibWert__( i, 1 ) 8114 # -- notizen --------------------------- 8115 , self.__gibWert__( i, 3 ) 8116 # -- ps.anmerkung.id ------------------- 8117 , self.__gibWert__( i, 0 ) 8118 # -- anmerkung ------------------------- 8119 , self.__gibWert__( i, 2 ) ] )

8120 8121 8122 8123 8124 8125 # 8126 # ------------------------------------------------------------------------------------ 8127 # ------------------------------------------------------------------------------------ 8128 # -- In der Datenbank verfügbare, projektbezogene Anmerkungen selektieren -- 8129 # ------------------------------------------------------------------------------------ 8130 # ------------------------------------------------------------------------------------ 8131 #

8132 - def selektiere__GefszenId_AnmId__Projekt__Sprache( self, TreeCtrlErg_ListBoxErg, ignorierePsGefszenarioId = False ):

8133 """ 8134 Methode zur Darstellung der in der Datenbank verfügbaren projektbezogenen Anmerkungen. 8135 8136 @note: Die übergebene Liste (C{TreeCtrlErg_ListBoxErg}) wird verändert ! 8137 8138 @param TreeCtrlErg_ListBoxErg: Es ist die Auswahlliste zu übergeben, die die Anmerkungen aufnimmt. 8139 @type TreeCtrlErg_ListBoxErg: TreeCtrlErg oder ListBoxErg 8140 8141 @param ignorierePsGefszenarioId: Es ist die C{True} anzugeben, wenn C{self.ps_gefszenario_id} in der SQL-Abfrage berücksichtigt werden soll. 8142 @type ignorierePsGefszenarioId: Boolean 8143 """ 8144 8145 # 8146 # -- Eingabefelde zurücksetzen ------------------------------------------ 8147 # 8148 TreeCtrlErg_ListBoxErg.loescheAlles() 8149 8150 8151 8152 # 8153 # -- es sind keine Anmerkungen darzustellen ---------------------------------- 8154 # 8155 if( len( self.daten__GefszenId_AnmId__Projekt__Sprache ) == 0 ) : return 8156 8157 8158 8159 # 8160 # -- >TreeCtrlErg< oder >ListBoxErg< ---------------------------------- 8161 # 8162 istTreeCtrlErg = ( str( TreeCtrlErg_ListBoxErg ).find( "wxPyTreeCtrl" ) >= 0 ) 8163 if( TreeCtrlErg_ListBoxErg is None ) : istTreeCtrlErg = None 8164 8165 8166 8167 # 8168 # -- Zur Gefahrenszenario-Id sind keine Werte zugeordnet ------------------ 8169 # 8170 if( self.ps_gefszenario_id not in self.daten__GefszenId_AnmId__Projekt__Sprache ) : 8171 8172 return 8173 8174 8175 8176 # 8177 # -- Hauptknoten übernehmen -------------------------------------------------- 8178 # -- (nur TreeCtrlErg) -------------------------------------------------- 8179 # 8180 if( istTreeCtrlErg ) : 8181 8182 TreeCtrlErg_ListBoxErg.nimmHauptknoten( wert = HK_ANM, bezHK = HK_ANM ) 8183 8184 8185 8186 # 8187 # -- Anmerkungen übernehmen ---------------------------------- 8188 # -- (ggf. Gefahrenszenario-Id durchlaufen) ---------------------------------- 8189 # 8190 for i in range( len( self.daten__GefszenId_AnmId__Projekt__Sprache ) ): 8191 8192 if( not ignorierePsGefszenarioId 8193 and ( self.daten__GefszenId_AnmId__Projekt__Sprache.keys()[i] != self.ps_gefszenario_id ) ) : 8194 8195 continue 8196 8197 aktPsGefszenId = self.daten__GefszenId_AnmId__Projekt__Sprache.keys()[i] 8198 for j in range( len( self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId] ) ): 8199 8200 wert = zk.gibIdWertNotizen( 8201 id = self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId][j][0] 8202 , zusInfo = "" 8203 , wert = self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId][j][2] 8204 , notizen = self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId][j][3] ) 8205 8206 clientData = [ # -- spr.uebvar.id --------------------- 8207 self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId][j][1] 8208 # -- notizen --------------------------- 8209 , self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId][j][3] 8210 # -- ps.anmerkung.id ------------------- 8211 , self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId][j][0] 8212 # -- anmerkung ------------------------- 8213 , self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId][j][2] ] 8214 8215 8216 if( istTreeCtrlErg ) : 8217 8218 TreeCtrlErg_ListBoxErg.nimmWert( 8219 wert = wert 8220 , wertId = None 8221 , dbId = self.daten__GefszenId_AnmId__Projekt__Sprache[aktPsGefszenId][j][0] 8222 , wertIdVorgaenger = '' 8223 , clientData = clientData ) 8224 8225 else : 8226 8227 TreeCtrlErg_ListBoxErg.nimmWert( wert = wert, clientData = clientData ) 8228 8229 8230 # 8231 # -- Baum darstellen -------------------------------------------------- 8232 # -- (nur TreeCtrlErg) -------------------------------------------------- 8233 # 8234 if( istTreeCtrlErg ) : 8235 8236 TreeCtrlErg_ListBoxErg.erzeugeBaum() 8237 TreeCtrlErg_ListBoxErg.markiereWert()

8238 8239 8240 8241 8242 8243 # 8244 # ------------------------------------------------------------------------------------ 8245 # ------------------------------------------------------------------------------------ 8246 # -- Wortgruppen setzen -------------------------------------------------- 8247 # ------------------------------------------------------------------------------------ 8248 # ------------------------------------------------------------------------------------ 8249 #

8250 - def selektiere__GefszenId_Wortgruppen__Projekt__Sprache( self, ListBoxErg_Gefszenario, ListBoxErg_ReprGefszenario ):

8251 """ 8252 Methode zum Setzen des Gefahrenszenarios / Repräsentativen Gefahrenszenarios. 8253 8254 @note: Die übergebenen Auswahlliste (C{ListBoxErg_Gefszenario, ListBoxErg_ReprGefszenario}) werden verändert ! 8255 8256 @param ListBoxErg_Gefszenario: Es ist die Auswahlliste zu übergeben, die das Gefahrenszenario aufnimmt. 8257 @type ListBoxErg_Gefszenario: ListBoxErg 8258 8259 @param ListBoxErg_ReprGefszenario: Es ist die Auswahlliste zu übergeben, die das repräsentative Gefahrenszenario aufnimmt. 8260 @type ListBoxErg_ReprGefszenario: ListBoxErg 8261 """ 8262 8263 # 8264 # -- Eingabefelder zurücksetzen ------------------------------------------ 8265 # 8266 ListBoxErg_Gefszenario.loescheAlles() 8267 ListBoxErg_ReprGefszenario.loescheAlles() 8268 8269 8270 8271 # 8272 # -- Zur Gefahrenszenario-Id sind keine Werte zugeordnet ------------------ 8273 # 8274 if( self.ps_gefszenario_id not in self.daten__GefszenId_Wortgruppen__Projekt__Sprache ) : 8275 8276 return 8277 8278 8279 # 8280 # -- Gefahrenszenario -------------------------------------------------- 8281 # 8282 ListBoxErg_Gefszenario.nimmWert( 8283 wert = ( self.daten__GefszenId_Wortgruppen__Projekt__Sprache[self.ps_gefszenario_id][0][1] 8284 + '\t|\t' 8285 + self.daten__GefszenId_Wortgruppen__Projekt__Sprache[self.ps_gefszenario_id][0][2] ) 8286 , clientData = [ # -- spr_uebvar_id --------------------- 8287 self.daten__GefszenId_Wortgruppen__Projekt__Sprache[self.ps_gefszenario_id][0][0] 8288 # -- notizen --------------------------- 8289 , self.daten__GefszenId_Wortgruppen__Projekt__Sprache[self.ps_gefszenario_id][0][2] ] ) 8290 ListBoxErg_Gefszenario.SetSelection( 0 ) 8291 8292 8293 8294 8295 # 8296 # -- Repräsentatives Gefahrenszenario ---------------------------------- 8297 # 8298 ListBoxErg_ReprGefszenario.nimmWert( 8299 wert = self.daten__GefszenId_Wortgruppen__Projekt__Sprache[self.ps_gefszenario_id][0][4] 8300 , clientData = [ # -- spr_uebvar_id_reprgefszen -------------------- 8301 self.daten__GefszenId_Wortgruppen__Projekt__Sprache[self.ps_gefszenario_id][0][3] ] ) 8302 ListBoxErg_ReprGefszenario.SetSelection( 0 )

8303 8304 8305 8306 8307 8308 8309 # 8310 # ------------------------------------------------------------------------------------ 8311 # ------------------------------------------------------------------------------------ 8312 # -- In der Datenbank verfügbare Firmen selektieren -------------------------- 8313 # ------------------------------------------------------------------------------------ 8314 # ------------------------------------------------------------------------------------ 8315 #

8316 - def selektiere__internFirma( self, TreeCtrlErg_ComboBoxErg, hatAlle = True ):

8317 """ 8318 Methode zur Darstellung der in der Datenbank verfügbaren Firmen. 8319 8320 @note: Die übergebene Auswahlliste (C{TreeCtrlErg_ComboBoxErg}) wird verändert ! 8321 8322 @param TreeCtrlErg_ComboBoxErg: Es ist die Auswahlliste zu übergeben, die die Werte aufnimmt. 8323 @type TreeCtrlErg_ComboBoxErg: TreeCtrlErg oder ComboBoxErg 8324 8325 @param hatAlle: Es ist C{True} anzugeben, wenn der Eintrag C{-- Alle Firmen --} hinzugefügt werden soll. 8326 @type hatAlle: Booean 8327 """ 8328 8329 # 8330 # -- Nullwert ---------------------------------------------------------- 8331 # 8332 alleTxt = [] 8333 if( hatAlle ) : alleTxt = [u"-- Alle Firmen --", [0]] 8334 8335 8336 8337 # 8338 # -- Eingabefelde zurücksetzen ------------------------------------------ 8339 # 8340 TreeCtrlErg_ComboBoxErg.loescheAlles() 8341 8342 8343 8344 # 8345 # -- es sind keine Strukturbezeichnungen darzustellen ------------------ 8346 # 8347 if( len( self.daten__internFirma ) == 0 ) : return 8348 8349 8350 8351 # 8352 # -- >TreeCtrlErg< oder >ComboBoxErg< ---------------------------------- 8353 # 8354 istTreeCtrlErg = ( str( TreeCtrlErg_ComboBoxErg ).find( "wxPyTreeCtrl" ) >= 0 ) 8355 8356 8357 8358 # 8359 # -- Werte übernehmen -------------------------------------------------- 8360 # 8361 if( istTreeCtrlErg ) : 8362 8363 # 8364 # -- Hauptknoten -------------------------------------------------- 8365 # 8366 TreeCtrlErg_ComboBoxErg.nimmHauptknoten( wert = HK_INTERNFIRMA, bezHK = HK_INTERNFIRMA ) 8367 8368 8369 # 8370 # -- Werte übernehmen ------------------------------------------ 8371 # 8372 for i in range( len( self.daten__internFirma ) ): 8373 8374 TreeCtrlErg_ComboBoxErg.nimmWert( 8375 wert = self.daten__internFirma[i][0] 8376 , wertId = None 8377 , dbId = self.daten__internFirma[i][1] 8378 , wertIdVorgaenger = '' 8379 , clientData = [ self.daten__internFirma[i][1] ] ) 8380 8381 else : 8382 8383 self.init__WxControlWithItemsPerm( permDaten = self.daten__internFirma 8384 , wxObjekt = TreeCtrlErg_ComboBoxErg 8385 , eintragNull = alleTxt )

8386 8387 8388 8389 8390 # 8391 # ------------------------------------------------------------------------------------ 8392 # ------------------------------------------------------------------------------------ 8393 # -- wxListBox der Tabelle 'ps.gefszenario' initialisieren ------------------ 8394 # ------------------------------------------------------------------------------------ 8395 # ------------------------------------------------------------------------------------ 8396 #

8397 - def selektiere__psGefszenario( self, wxListBox ):

8398 """ 8399 Methode zur Initialisierung der Auswahlliste (C{wxListBox}), die die Gefahrenszenario-Id gültig im aktuell übergebenen Projekt aufnimmt (darstellt). 8400 8401 ACHTUNG, die Datenbankabfrage erfolgt bei jedem Aufruf der Methode ! Die permanenten Datenstrukturen werden nicht verwendet. 8402 8403 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 8404 8405 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Gefahrenszenario-Id aufnimmt. 8406 @type wxListBox: wxPython - ListBox 8407 """ 8408 8409 # 8410 # -- >wxListBox< leeren -------------------------------------------------- 8411 # 8412 wxListBox.Clear() 8413 8414 8415 8416 # 8417 # -- >ps.gefszenario.id< anhand der zusätzlichen Filterkriterien ---------- 8418 # -- einschränken ---------- 8419 # 8420 listePsGefszenarioId = self.__gibFilterZusKrit__PsGefszenarioId__() 8421 if( listePsGefszenarioId is not None ) : 8422 8423 if( len( listePsGefszenarioId ) == 0 ) : return 8424 8425 listePsGefszenarioId = """ 8426 AND 8427 prj.zeige__pp_psgefszenario.ps_gefszenario_id IN( """ + listePsGefszenarioId + " )" 8428 8429 else : 8430 8431 listePsGefszenarioId = "" 8432 8433 8434 8435 # 8436 # -- in Protokolldatei schreiben ------------------------------------------ 8437 # 8438 self.ProtokolldateiEintragen( eintrag = "selektiere__psGefszenario()" 8439 , istKopfzeile = True ) 8440 8441 8442 8443 # 8444 # -- SQL-Abfrage ausführen, -------------------------- 8445 # -- die gelesenen Werte der ListBox zuordnen -------------------------- 8446 # 8447 self.__initWxControlWithItems__( """ 8448 SELECT DISTINCT 8449 prj.zeige__pp_psgefszenario.ps_gefszenario_id 8450 FROM 8451 prj.zeige__pp_psgefszenario 8452 WHERE 8453 -- 8454 -- Projekt auswählen 8455 -- 8456 prj.zeige__pp_psgefszenario.prj_projekte_id = """ + str( self.filter__prj_projekte_id ) + """ 8457 AND 8458 -- 8459 -- gültige Datensätze anzeigen 8460 -- 8461 prj.zeige__pp_psgefszenario.ps_gefszenario_id > 0""" 8462 8463 + listePsGefszenarioId + """ 8464 ORDER BY 8465 prj.zeige__pp_psgefszenario.ps_gefszenario_id 8466 ;""" 8467 , [] 8468 , wxListBox 8469 , formatiereWert = 1 ) 8470 8471 8472 8473 # 8474 # -- erste Gefahrenszenario-Id auswählen und übernehmen ------------------ 8475 # 8476 wxListBox.SetSelection( 0 ) 8477 self.nimm__PsGefszenarioId( wxListBox = wxListBox )

8478 8479 8480 8481 8482 8483 8484 8485 # 8486 # ------------------------------------------------------------------------------------ 8487 # ------------------------------------------------------------------------------------ 8488 # -- Datum setzen ---------------------------------------------------------- 8489 # ------------------------------------------------------------------------------------ 8490 # ------------------------------------------------------------------------------------ 8491 #

8492 - def selektiere__ProtId_DatUhrz__Projekt( self, MaskedTextCtrlErg, prtProtokollId, istDatum_PE_Termin_Anfrage = None ):

8493 """ 8494 Methode zur Auswahl der Teilnehmer oder Personen, denen eine Aufgabe gestellt wurde. 8495 8496 @note: Die übergebene Liste (C{MaskedTextCtrlErg}) wird verändert ! 8497 8498 @param MaskedTextCtrlErg: Es ist das Datum-Texteingabefeld zu übergeben. 8499 @type MaskedTextCtrlErg: MaskedTextCtrlErg 8500 8501 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Protokolleintrages zu übergeben. 8502 @type prtProtokollId: list (Ganzzahl) 8503 8504 @param istDatum_PE_Termin_Anfrage: Wird C{None} angegeben, wird das Datum des Protokolleintrages gesetzt. Wird C{True} angegeben, wird der Termin zur Lösung der Aufgabe gesetzt. Wird C{False} angegeben, wird das Datum des Übersendens der Aufgabe gesetzt. 8505 @type istDatum_PE_Termin_Anfrage: Boolean 8506 """ 8507 8508 # 8509 # -- Datum zurücksetzen -------------------------------------------------- 8510 # 8511 MaskedTextCtrlErg.loescheAlles() 8512 8513 8514 8515 # -- Datum ------------------------------------------------------------------ 8516 # -- ---------------------------------- 8517 # -- 1. Datum des Protokolleintrages ---------------------------------- 8518 # -- 2. Termin zur Lösung der Aufgabe ---------------------------------- 8519 # -- 3. Datum des Übersendens der Aufgabe ---------------------------------- 8520 # -- ---------------------------------- 8521 # 8522 daten__ProtId_DatUhrz = None 8523 8524 if( istDatum_PE_Termin_Anfrage is None ) : 8525 8526 daten__ProtId_DatUhrz = self.daten__ProtId_DatUhrz_teilnehmer__Projekt 8527 8528 else : 8529 8530 daten__ProtId_DatUhrz = self.daten__ProtId_DatUhrz_aufgabe__Projekt 8531 8532 8533 8534 # 8535 # -- Zur Protokoll-Id ist kein Datum zugeordnet -------------------------- 8536 # 8537 if( prtProtokollId not in daten__ProtId_DatUhrz ) : 8538 8539 return 8540 8541 8542 8543 # 8544 # -- Datum setzen ---------------------------------------------------------- 8545 # -- ---------------------------------- 8546 # -- 1. Datum des Protokolleintrages ---------------------------------- 8547 # -- 2. Termin zur Lösung der Aufgabe ---------------------------------- 8548 # -- 3. Datum des Übersendens der Aufgabe ---------------------------------- 8549 # -- ---------------------------------- 8550 # 8551 if( istDatum_PE_Termin_Anfrage is None ) : 8552 8553 MaskedTextCtrlErg.nimmWert( wert = daten__ProtId_DatUhrz[prtProtokollId][0][0] ) 8554 8555 elif( istDatum_PE_Termin_Anfrage is True ) : 8556 8557 MaskedTextCtrlErg.nimmWert( wert = daten__ProtId_DatUhrz[prtProtokollId][0][0] ) 8558 8559 else : 8560 8561 MaskedTextCtrlErg.nimmWert( wert = daten__ProtId_DatUhrz[prtProtokollId][0][1] )

8562 8563 8564 8565 8566 8567 8568 # 8569 # ------------------------------------------------------------------------------------ 8570 # ------------------------------------------------------------------------------------ 8571 # -- CheckBox setzen ---------------------------------------------------------- 8572 # ------------------------------------------------------------------------------------ 8573 # ------------------------------------------------------------------------------------ 8574 #

8575 - def selektiere__ProtId_DatUhrz_ChBx__Projekt( self, CheckBoxErg_Erledigt, CheckBoxErg_Intern, prtProtokollId ):

8576 """ 8577 Methode zum Setzen der Auswahlboxen 'Erledigt' und 'Intern'. 8578 8579 @note: Die übergebenen Auswahlfelder (C{CheckBoxErg_Erledigt, CheckBoxErg_Intern}) werden verändert ! 8580 8581 @param CheckBoxErg_Erledigt: Es ist das Eingabefeld auszuwählen, wenn der Protokolleintrag erledigt ist. 8582 @type CheckBoxErg_Erledigt: CheckBoxErg 8583 8584 @param CheckBoxErg_Intern: Es ist das Eingabefeld auszuwählen, wenn der Protokolleintrag nur intern zu verwenden ist. 8585 @type CheckBoxErg_Intern: CheckBoxErg 8586 8587 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Protokolleintrages zu übergeben. 8588 @type prtProtokollId: list (Ganzzahl) 8589 """ 8590 8591 # 8592 # -- Eingabefelder zurücksetzen ------------------------------------------ 8593 # 8594 CheckBoxErg_Erledigt.nimmWert( wert = False ) 8595 CheckBoxErg_Intern.nimmWert( wert = False ) 8596 8597 8598 8599 # 8600 # -- Zur Protokoll-Id sind keine Werte zugeordnet -------------------------- 8601 # 8602 if( prtProtokollId not in self.daten__ProtId_DatUhrz_teilnehmer__Projekt ) : 8603 8604 return 8605 8606 8607 8608 # 8609 # -- Eingefeld setzen -------------------------------------------------- 8610 # 8611 CheckBoxErg_Erledigt.nimmWert( wert = self.daten__ProtId_DatUhrz_teilnehmer__Projekt[prtProtokollId][0][1] ) 8612 CheckBoxErg_Intern.nimmWert( wert = self.daten__ProtId_DatUhrz_teilnehmer__Projekt[prtProtokollId][0][2] )

8613 8614 8615 8616 8617 8618 8619 # 8620 # ------------------------------------------------------------------------------------ 8621 # ------------------------------------------------------------------------------------ 8622 # -- Personen auswählen -------------------------------------------------- 8623 # ------------------------------------------------------------------------------------ 8624 # ------------------------------------------------------------------------------------ 8625 #

8626 - def selektiere__ProtId_PersId__Projekt( self, ListBoxSpWTitelAL, prtProtokollId, istAufgabe = True ):

8627 """ 8628 Methode zur Auswahl der Teilnehmer oder Personen, denen eine Aufgabe gestellt wurde. 8629 8630 @note: Die übergebene Liste (C{ListBoxSpWTitelAL}) wird verändert ! 8631 8632 @param ListBoxSpWTitelAL: Es ist die Listbox mit Auswahlliste zu übergeben, die die Personen aufnimmt. 8633 @type ListBoxSpWTitelAL: TreeCtrlErg 8634 8635 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Protokolleintrages zu übergeben. 8636 @type prtProtokollId: list (Ganzzahl) 8637 8638 @param istAufgabe: Wird C{True} angegeben, wird an die Person(en) eine Frage/Aufgabe gestellt; andernfalls sind die Personen Teilnehmer beim Erzeugen des Protokolleintrages. 8639 @type istAufgabe: Boolean 8640 """ 8641 8642 8643 # 8644 # -- Alle Personen zurücksetzen ------------------------------------------ 8645 # 8646 ListBoxSpWTitelAL.schiebeAlleRechts() 8647 8648 8649 8650 # 8651 # -- Personen mit Aufgaben oder Teilnehmer ? -------------------------- 8652 # 8653 daten__ProtId_PersId = None 8654 8655 if( istAufgabe ) : 8656 8657 daten__ProtId_PersId = self.daten__ProtId_PersId_aufgabe__Projekt 8658 8659 else : 8660 8661 daten__ProtId_PersId = self.daten__ProtId_PersId_teilnehmer__Projekt 8662 8663 8664 # 8665 # -- Zur Protokoll-Id ist keine Person zugeordnet -------------------------- 8666 # 8667 if( prtProtokollId not in daten__ProtId_PersId ) : 8668 8669 return 8670 8671 8672 8673 # 8674 # -- Personen auswählen -------------------------------------------------- 8675 # 8676 for i in range( len( daten__ProtId_PersId[prtProtokollId] ) ): 8677 8678 ListBoxSpWTitelAL.schiebeLinks( daten__ProtId_PersId[prtProtokollId][i][0] )

8679 8680 8681 8682 8683 8684 8685 # 8686 # ------------------------------------------------------------------------------------ 8687 # ------------------------------------------------------------------------------------ 8688 # -- Sicht >prj.zeige__pl_prtpsgefszenario< auslesen ------------------ 8689 # ------------------------------------------------------------------------------------ 8690 # ------------------------------------------------------------------------------------ 8691 #

8692 - def selektiere__prtProtokoll( self, TreeCtrlErg, prtTypId = None, ignorierePsGefszenarioId = False ):

8693 """ 8694 Methode zum Eintragen der Sicherheitsanforderungen und Gefahrenprotokolleinträge. 8695 8696 @note: Die übergebene Baumstruktur (C{TreeCtrlErg}) wird verändert ! 8697 8698 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die Gefahrenprotokolleinträge aufnimmt. 8699 @type TreeCtrlErg: TreeCtrlErg 8700 8701 @param prtTypId: Es ist die Datenbankidentifikationsnummer (C{prt.typ.id}) des Typs des aktuellen Protokolleintrages zu übergeben. 8702 @type prtTypId: Ganzzahl 8703 8704 @param ignorierePsGefszenarioId: Es ist die C{True} anzugeben, wenn C{self.ps_gefszenario_id} in der SQL-Abfrage berücksichtigt werden soll. 8705 @type ignorierePsGefszenarioId: Boolean 8706 """ 8707 8708 # 8709 # -- in Protokolldatei schreiben ------------------------------------------ 8710 # 8711 # 8712 # fortsetzen 8713 # 8714 # print "selektiere__prtProtokoll()" 8715 8716 self.ProtokolldateiEintragen( eintrag = "selektiere__prtProtokoll()" 8717 , istKopfzeile = True ) 8718 8719 8720 8721 # 8722 # -- Datenbankabfrage ausführen ------------------------------------------ 8723 # 8724 self.__dbAbfrage__( self.__gibSQL_psPrtProtokoll__( prtTypAspekt = 'SF' 8725 , prtTypId = prtTypId 8726 , sqlINpsGefszenId = True 8727 , prtProtokollIdVorg = None 8728 , prtProtokollIdNachf = None 8729 , ignorierePrjProjekteId = False 8730 , ignoriereSprSprachenId = False 8731 , ignorierePsGefszenarioId = ignorierePsGefszenarioId ) ) 8732 8733 8734 # 8735 # -- es sind keine Protokolleinträge darzustellen -------------------------- 8736 # 8737 if( self.__gibAnzZeilen__() == 0 ) : return 8738 8739 8740 # 8741 # -- Hauptknoten übernehmen -------------------------------------------------- 8742 # 8743 TreeCtrlErg.nimmHauptknoten( wert = HK_SIANF, bezHK = HK_SIANF ) 8744 8745 8746 8747 # 8748 # -- Protokolleinträge eintragen ---------------------------------- 8749 # 8750 tmpId = [] 8751 for i in range( self.__gibAnzZeilen__() ): 8752 8753 # 8754 # -- prüfen ob die Kombination aus Protokoll-Id (Vorgänger) ---------- 8755 # -- und Protokoll-Id bereits eingelesen wurden ---------- 8756 # 8757 tmp = ( str( self.__dbAbfrage__Ergebnis[i][4] ) + '-' + str( self.__gibWert__( i, 3 ) ) ) 8758 8759 if( tmp in tmpId ) : 8760 8761 continue 8762 8763 tmpId.append( tmp ) 8764 8765 8766 8767 # 8768 # -- Werte übernehmen ------------------------------------------ 8769 # 8770 # -- nur für Sicherheitsanforderung ---------------------------------- 8771 # 8772 # 20 | 01: Technische Maßnahme (Konstruktion) -- 8773 # 21 | 01: Technische Maßnahme (Sicherheitsfunktion) -- 8774 # -- 8775 # 22 | 01: Dokumentationsanforderung an den Fahrzeughersteller -- 8776 # 23 | 01: Vom Fahrzeughersteller durchzuführende Prüfung -- 8777 # 24 | 02: Während des Betriebseinsatzes durchzuführende Maßnahme -- 8778 # 25 | 02: In die Bedienungsanleitung aufzunehmende Anforderung -- 8779 # 26 | 03: Instandhaltungsmaßnahme -- 8780 # 27 | 03: In die Instandhaltungsdokumentation aufzunehmende Anforderung -- 8781 # 8782 zusInfo = " [O]" 8783 8784 if( self.__gibWert__( i, 1 ) in self.konstante__prt_typ_id__siAnf[0:2] ) : 8785 8786 zusInfo = " [T]" 8787 8788 8789 TreeCtrlErg.nimmWert( zk.gibIdWertNotizen( id = self.__gibWert__( i, 3 ) 8790 , zusInfo = zusInfo 8791 , wert = self.__gibWert__( i, 2 ) 8792 , notizen = self.__gibWert__( i, 6 ) ) 8793 , wertId = None 8794 , dbId = self.__gibWert__( i, 3 ) 8795 , wertIdVorgaenger = self.__gibWert__( i, 4 ) 8796 , clientData = [ # -- prj.pp_prtprotokoll.id --- 8797 self.__gibWert__( i, 7 ) 8798 # -- spr.uebvar.id --------------------- 8799 , self.__gibWert__( i, 5 ) 8800 # -- notizen --------------------------- 8801 , self.__gibWert__( i, 6 ) ] )

8802 8803 8804 8805 8806 8807 8808 # 8809 # ------------------------------------------------------------------------------------ 8810 # ------------------------------------------------------------------------------------ 8811 # -- In der Datenbank verfügbare, projektbezogene ------------------ 8812 # -- Sicherheitsanforderungen / Gefahrenprotokolleinträge ------------------ 8813 # ------------------------------------------------------------------------------------ 8814 # ------------------------------------------------------------------------------------ 8815 #

8816 - def selektiere__prtProtokoll__Projekt__Sprache( self, TreeCtrlErg, istGefProt = True, prtTypId = None, prtProtokollId = None ):

8817 """ 8818 Methode zur Darstellung der in der Datenbank verfügbaren projektbezogenen Sicherheitsanforderungen / Gefahrenprotokolleinträge. 8819 8820 @note: Die übergebene Liste (C{TreeCtrlErg}) wird verändert ! 8821 8822 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die Protokolleinträge aufnimmt. 8823 @type TreeCtrlErg: TreeCtrlErg 8824 8825 @param istGefProt: Wird C{True} angegeben, liegen Gefahrenprotokolleinträge vor; andernfalls Sicherheitsanforderungen. 8826 @type istGefProt: Boolean 8827 8828 @param prtTypId: Es ist die Datenbankidentifikationsnummer (C{prt.typ.id}) des Typs des aktuellen Protokolleintrages zu übergeben. 8829 @type prtTypId: list (Ganzzahl) 8830 8831 @param prtProtokollId: Es ist die Datenbankidentifikationsnummer (C{prt.protokoll.id}) des Protokolleintrages zu übergeben. 8832 @type prtProtokollId: list (Ganzzahl) 8833 """ 8834 8835 # 8836 # -- Gefahrenprotokolleinträge oder Sicherheitsanforderungen ? ---------- 8837 # 8838 daten__prtProtokoll = None 8839 8840 if( istGefProt ) : 8841 8842 daten__prtProtokoll = self.daten__prtProtokoll_gefProt__Projekt__Sprache 8843 daten__prtProtokoll_vorg = self.daten__prtProtokoll_gefProt_vorg__Projekt__Sprache 8844 8845 else : 8846 8847 daten__prtProtokoll = self.daten__prtProtokoll_siAnf__Projekt__Sprache 8848 daten__prtProtokoll_vorg = self.daten__prtProtokoll_siAnf_vorg__Projekt__Sprache 8849 8850 8851 8852 # 8853 # -- es sind keine Protokolleinträge darzustellen -------------------------- 8854 # 8855 if( len( daten__prtProtokoll ) == 0 ) : return 8856 8857 8858 8859 # 8860 # -- Hauptknoten übernehmen -------------------------------------------------- 8861 # 8862 if( istGefProt ) : 8863 8864 TreeCtrlErg.nimmHauptknoten( wert = HK_PE, bezHK = HK_PE ) 8865 8866 else : 8867 8868 TreeCtrlErg.nimmHauptknoten( wert = HK_SIANF, bezHK = HK_SIANF ) 8869 8870 8871 8872 # 8873 # -- Protokolleinträge übernehmen ------------------------------------------ 8874 # -- 8875 # -- [0] prj.zeige__prtprotokoll.prt__protokoll__id -- 8876 # -- [1] Protokolleintrag (Zeichenkette) -- 8877 # -- [2] prj.zeige__prtprotokoll.prj__pp_prtprotokoll__notizen -- 8878 # -- [3] prj.zeige__prtprotokoll.prt__typ__id -- 8879 # -- [4] prj.zeige__prtprotokoll.prj__pp_prtprotokoll__spr_uebvar_id -- 8880 # -- 8881 for i in daten__prtProtokoll.iteritems() : 8882 8883 # 8884 # -- nach >prt.typ.aspekt< selektieren -- 8885 # -- (Gefahrenprotokolleinträge und Sicherheitsanforderungen -- 8886 # -- unterscheiden) -- 8887 # 8888 if( istGefProt and i[1][0][2] not in self.konstante__prt_typ_id__gefProt ) : 8889 8890 continue 8891 8892 elif( not istGefProt and i[1][0][2] not in self.konstante__prt_typ_id__siAnf ) : 8893 8894 continue 8895 8896 8897 # 8898 # -- nach Typ des Protokolleintrages selektieren ------------------ 8899 # 8900 if( prtTypId is not None and i[1][0][2] not in prtTypId ) : 8901 8902 continue 8903 8904 8905 # 8906 # -- nach Protokoll-Id selektieren ---------------------------------- 8907 # 8908 if( prtProtokollId is not None and [i[0]] not in prtProtokollId ) : 8909 8910 continue 8911 8912 8913 # 8914 # -- Protokolleinträge übernehmen ---------------------------------- 8915 # 8916 wertIdVorgaenger = None 8917 if( i[0] in daten__prtProtokoll_vorg ): 8918 8919 wertIdVorgaenger = daten__prtProtokoll_vorg[i[0]][0][0] 8920 8921 8922 # 8923 # -- nur für Sicherheitsanforderung ---------------------------------- 8924 # 8925 # 20 | 01: Technische Maßnahme (Konstruktion) -- 8926 # 21 | 01: Technische Maßnahme (Sicherheitsfunktion) -- 8927 # -- 8928 # 22 | 01: Dokumentationsanforderung an den Fahrzeughersteller -- 8929 # 23 | 01: Vom Fahrzeughersteller durchzuführende Prüfung -- 8930 # 24 | 02: Während des Betriebseinsatzes durchzuführende Maßnahme -- 8931 # 25 | 02: In die Bedienungsanleitung aufzunehmende Anforderung -- 8932 # 26 | 03: Instandhaltungsmaßnahme -- 8933 # 27 | 03: In die Instandhaltungsdokumentation aufzunehmende Anforderung -- 8934 # 8935 zusInfo = "" 8936 if( not istGefProt ) : 8937 8938 zusInfo = " [O]" 8939 8940 if( i[1][0][2] in self.konstante__prt_typ_id__siAnf[0:2] ) : 8941 8942 zusInfo = " [T]" 8943 8944 8945 TreeCtrlErg.nimmWert( zk.gibIdWertNotizen( id = i[0] 8946 , zusInfo = zusInfo 8947 , wert = i[1][0][0] 8948 , notizen = i[1][0][1] ) 8949 , wertId = None 8950 , dbId = i[0] 8951 , wertIdVorgaenger = wertIdVorgaenger 8952 , clientData = [ # -- prj.pp_prtprotokoll.id --- 8953 # i[1][0][6] 8954 None 8955 # -- spr.uebvar.id --------------------- 8956 , i[1][0][3] 8957 # -- notizen --------------------------- 8958 , i[1][0][1] ] )

8959 8960 8961 8962 8963 8964 8965 # 8966 # ------------------------------------------------------------------------------------ 8967 # ------------------------------------------------------------------------------------ 8968 # -- In der Datenbank verfügbare Strukturbezeichnungen selektieren ---------- 8969 # ------------------------------------------------------------------------------------ 8970 # ------------------------------------------------------------------------------------ 8971 #

8972 - def selektiere__prtTyp__Sprache( self, TreeCtrlErg_ComboBoxErg, prtTypAspekt, hatAlle = False ):

8973 """ 8974 Methode zur Darstellung der in der Datenbank verfügbaren Typen der Protokolleinträge / Sicherheitsanforderungen / Terminplaneinträge. 8975 8976 @note: Die übergebene Auswahlliste (C{TreeCtrlErg_ComboBoxErg}) wird verändert ! 8977 8978 @param TreeCtrlErg_ComboBoxErg: Es ist die Auswahlliste zu übergeben, die die Werte aufnimmt. 8979 @type TreeCtrlErg_ComboBoxErg: TreeCtrlErg oder ComboBoxErg 8980 8981 @param prtTypAspekt: Es ist der Aspekt (Protokolleintrag, Sicherheitsanforderung) anzugeben. Er darf C{None} sein. 8982 @type prtTypAspekt: Zeichenkette 8983 8984 @param hatAlle: Es ist C{True} anzugeben, wenn der Eintrag C{-- Alle Typen --} hinzugefügt werden soll 8985 @type hatAlle: Booean 8986 """ 8987 8988 # 8989 # -- Nullwert ---------------------------------------------------------- 8990 # 8991 alleTxt = [] 8992 if( hatAlle ) : alleTxt = [u"-- Alle Typen --", [0]] 8993 8994 8995 8996 # 8997 # -- Eingabefelde zurücksetzen ------------------------------------------ 8998 # 8999 TreeCtrlErg_ComboBoxErg.loescheAlles() 9000 9001 9002 9003 # 9004 # -- es sind keine Typen darzustellen ---------------------------------- 9005 # 9006 if( len( self.daten__prtTyp__Sprache ) == 0 ) : return 9007 9008 9009 9010 # 9011 # -- >TreeCtrlErg< oder >ComboBoxErg< ---------------------------------- 9012 # 9013 istTreeCtrlErg = ( str( TreeCtrlErg_ComboBoxErg ).find( "wxPyTreeCtrl" ) >= 0 ) 9014 9015 9016 9017 # 9018 # -- Werte übernehmen -------------------------------------------------- 9019 # 9020 if( istTreeCtrlErg ) : 9021 9022 # 9023 # -- Hauptknoten -------------------------------------------------- 9024 # 9025 if( prtTypAspekt == "PE" ) : 9026 9027 TreeCtrlErg_ComboBoxErg.nimmHauptknoten( wert = HK_PETYP, bezHK = HK_PETYP ) 9028 9029 else : 9030 9031 TreeCtrlErg_ComboBoxErg.nimmHauptknoten( wert = HK_SIANFTYP, bezHK = HK_SIANFTYP ) 9032 9033 9034 # 9035 # -- Werte übernehmen ------------------------------------------ 9036 # 9037 for i in range( len( self.daten__prtTyp__Sprache ) ): 9038 9039 if( self.daten__prtTyp__Sprache[i][2] != prtTypAspekt ) : continue 9040 9041 TreeCtrlErg_ComboBoxErg.nimmWert( 9042 wert = self.daten__prtTyp__Sprache[i][0] 9043 , wertId = None 9044 , dbId = self.daten__prtTyp__Sprache[i][1] 9045 , wertIdVorgaenger = '' 9046 , clientData = [ self.daten__prtTyp__Sprache[i][1] ] ) 9047 9048 else : 9049 9050 self.init__WxControlWithItemsPerm( permDaten = self.daten__prtTyp__Sprache 9051 , wxObjekt = TreeCtrlErg_ComboBoxErg 9052 , eintragNull = alleTxt 9053 , filter = prtTypAspekt )

9054 9055 9056 9057 # 9058 # ------------------------------------------------------------------------------------ 9059 # ------------------------------------------------------------------------------------ 9060 # -- wxComboBox der Tabelle 'spr.sprachen' initialisieren ------------------ 9061 # ------------------------------------------------------------------------------------ 9062 # ------------------------------------------------------------------------------------ 9063 #

9064 - def selektiere__sprWgruppe( self, wxListBox, sprUebvarId ):

9065 """ 9066 Methode zur Initialisierung der Auswahlliste (C{wxListBox}), welche die in der Datenbank verfügbaren Übersetzungen zur gegebenenen Übersetzungsvariante C{sprUebvarId} aufnimmt (darstellt). 9067 9068 @note: Die übergebene Auswahlliste (C{wxListBox}) wird verändert ! 9069 9070 @param wxListBox: Es ist die Auswahlliste zu übergeben, die die Strukturpunkte aufnimmt. 9071 @type wxListBox: wxPython - ListBox 9072 9073 @param sprUebvarId : Es ist die Id der Übersetzungsvariante C{spr.uebvar.id} zu übergeben. 9074 @type sprUebvarId : C{Ganzzahl} 9075 """ 9076 9077 # 9078 # -- in Protokolldatei schreiben ------------------------------------------ 9079 # 9080 # 9081 # fortsetzen 9082 # 9083 # print "selektiere__sprWgruppe()" 9084 9085 self.ProtokolldateiEintragen( eintrag = "selektiere__sprWgruppe()" 9086 , istKopfzeile = True ) 9087 9088 9089 9090 # 9091 # gültige SQL-Abfrage erzeugen, 9092 # die gelesenen Werte der ComboBox zuordnen und 9093 # den ersten Eintrag auswählen 9094 # 9095 9096 self.__initWxControlWithItems__( """ 9097 SELECT DISTINCT 9098 spr.zeige__wgruppe.wgruppe 9099 , spr_sprachen_id 9100 FROM 9101 spr.zeige__wgruppe 9102 WHERE 9103 spr.zeige__wgruppe.spr_uebvar_id = """ + str( sprUebvarId ) + """;""" 9104 , [] 9105 , wxListBox )

9106 9107 9108 9109 9110 9111 9112 # 9113 # ------------------------------------------------------------------------------------ 9114 # ------------------------------------------------------------------------------------ 9115 # -- In der Datenbank verfügbare Strukturbezeichnungen selektieren ---------- 9116 # ------------------------------------------------------------------------------------ 9117 # ------------------------------------------------------------------------------------ 9118 #

9119 - def selektiere__strName( self, TreeCtrlErg_ComboBoxErg ) :

9120 """ 9121 Methode zur Darstellung der in der Datenbank verfügbaren Strukturbezeichnungen. 9122 9123 @note: Die übergebene Auswahlliste (C{TreeCtrlErg_ComboBoxErg}) wird verändert ! 9124 9125 @param TreeCtrlErg_ComboBoxErg: Es ist die Auswahlliste zu übergeben, die die Werte aufnimmt. 9126 @type TreeCtrlErg_ComboBoxErg: TreeCtrlErg oder ComboBoxErg 9127 """ 9128 9129 # 9130 # -- Eingabefelde zurücksetzen ------------------------------------------ 9131 # 9132 TreeCtrlErg_ComboBoxErg.loescheAlles() 9133 9134 9135 9136 # 9137 # -- es sind keine Strukturbezeichnungen darzustellen ------------------ 9138 # 9139 if( len( self.daten__strName ) == 0 ) : return 9140 9141 9142 9143 # 9144 # -- >TreeCtrlErg< oder >ComboBoxErg< ---------------------------------- 9145 # 9146 istTreeCtrlErg = ( str( TreeCtrlErg_ComboBoxErg ).find( "wxPyTreeCtrl" ) >= 0 ) 9147 9148 9149 9150 # 9151 # -- Werte übernehmen -------------------------------------------------- 9152 # 9153 if( istTreeCtrlErg ) : 9154 9155 # 9156 # -- Hauptknoten -------------------------------------------------- 9157 # 9158 TreeCtrlErg_ComboBoxErg.nimmHauptknoten( wert = HK_STRBEZ, bezHK = HK_STRBEZ ) 9159 9160 9161 # 9162 # -- Werte übernehmen ------------------------------------------ 9163 # 9164 for i in range( len( self.daten__strName ) ): 9165 9166 TreeCtrlErg_ComboBoxErg.nimmWert( 9167 wert = self.daten__strName[i][0] 9168 , wertId = None 9169 , dbId = self.daten__strName[i][1] 9170 , wertIdVorgaenger = '' 9171 , clientData = [ self.daten__strName[i][1] ] ) 9172 9173 else : 9174 9175 self.init__WxControlWithItemsPerm( permDaten = self.daten__strName 9176 , wxObjekt = TreeCtrlErg_ComboBoxErg 9177 , eintragNull = [u"-- Alle Strukturen --", [0]] )

9178 9179 9180 9181 9182 9183 9184 9185 # 9186 # ------------------------------------------------------------------------------------ 9187 # ------------------------------------------------------------------------------------ 9188 # -- In der Datenbank verfügbare Strukturpunkte selektieren ------------------ 9189 # ------------------------------------------------------------------------------------ 9190 # ------------------------------------------------------------------------------------ 9191 #

9192 - def selektiere__strStrkt( self, TreeCtrlErg, strNameId = None ):

9193 """ 9194 Methode zur Darstellung der in der Datenbank verfügbaren Strukturpunkte. 9195 9196 @note: Die übergebene Liste (C{TreeCtrlErg}) wird verändert ! 9197 9198 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die Strukturpunkte aufnimmt. 9199 @type TreeCtrlErg: TreeCtrlErg 9200 9201 @param strNameId: Es ist die Datenbankidentifikationsnummer (C{str.name.id}) der Strukturbezeichnung zu übergeben, die dargestellt werden soll. 9202 @type strNameId: Ganzzahl 9203 """ 9204 9205 # 9206 # -- Es ist kein Gefahrenszenario vorhanden -------------------------- 9207 # -- -> Datenbankabfrage wird nicht ausgeführt -------------------------- 9208 # 9209 if( self.ps_gefszenario_id is None ) : 9210 9211 return None 9212 9213 9214 9215 # 9216 # -- in Protokolldatei schreiben ------------------------------------------ 9217 # 9218 # 9219 # fortsetzen 9220 # 9221 # print "selektiere__strStrkt()" 9222 9223 self.ProtokolldateiEintragen( eintrag = "selektiere__strStrkt()" 9224 , istKopfzeile = True ) 9225 9226 9227 9228 # 9229 # -- Strukturnamen einschränken ------------------------------------------ 9230 # 9231 strName = '' 9232 if( strNameId is not None ) : 9233 strName = """ 9234 AND 9235 -- 9236 -- -- Strukturnamen auswählen ---------------------------------- 9237 -- 9238 prj.zeige__strstrkt.str__name__id IN( """ + str( strNameId ).replace( '[', '' ).replace( ']', '' ) + """ ) 9239 """ 9240 9241 9242 9243 # 9244 # -- SQL-Abfrage ausführen -------------------------------------------------- 9245 # 9246 self.__dbAbfrage__( """ 9247 -- 9248 -- Strukturpunkte - es wird der jeweils letzte zugeordnete Eintrag angezeigt 9249 -- (Logbuchfunktion) 9250 -- 9251 SELECT DISTINCT 9252 -- 0 9253 prj.zeige__strstrkt.str__strkt__nr || ' ' || COALESCE( spr.zeige__wgruppe.wgruppe, '??' ) AS strpkt 9254 , prj.zeige__strstrkt.str__strkt__id 9255 -- 2 9256 , nachfok.str__strkt__id AS str_strkt_id__vorg 9257 , prj.zeige__strstrkt.str__name__name_k 9258 -- 4 9259 , prj.zeige__strstrkt.str__name__id 9260 FROM 9261 prj.zeige__strstrkt 9262 -- 9263 -- Strukturpunkt 9264 -- 9265 LEFT OUTER JOIN spr.zeige__wgruppe 9266 ON ( 9267 prj.zeige__strstrkt.prj__pp_strstrkt__spr_uebvar_id = 9268 spr.zeige__wgruppe.spr_uebvar_id 9269 AND 9270 -- 9271 -- Sprache Auswählen 9272 -- 9273 spr.zeige__wgruppe.spr_sprachen_id = """ 9274 + str( self.filter__spr_sprachen_id ) + """ 9275 ) 9276 -- 9277 -- aktueller Strukturpunkt ist ein gültiger Nachfolger 9278 -- 9279 LEFT OUTER JOIN prj.zeige__strstrkt AS nachfok 9280 ON ( 9281 nachfok.prj__p_strverbindung__str_strkt_id_nachf = 9282 prj.zeige__strstrkt.str__strkt__id 9283 AND 9284 nachfok.prj_projekte_id = prj.zeige__strstrkt.prj_projekte_id 9285 ) 9286 , prj.zeige__prtprotokolltabellen 9287 , prj.zeige__pl_prtpsgefszenario 9288 WHERE 9289 -- 9290 -- -- Gefahrennetz nicht anzeigen ---------------------------------- 9291 -- 9292 prj.zeige__strstrkt.str__name__id != 2""" + strName + """ 9293 AND 9294 -- 9295 -- -- Strukturpunkt zuordnen ------------------------------------------ 9296 -- 9297 prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__str_strkt_id = 9298 prj.zeige__strstrkt.str__strkt__id 9299 AND 9300 -- 9301 -- -- Projekt zuordnen ------------------------------------------ 9302 -- 9303 prj.zeige__prtprotokolltabellen.prj__p_prtstrstrkt__prj_projekte_id = 9304 prj.zeige__strstrkt.prj_projekte_id 9305 AND 9306 prj.zeige__pl_prtpsgefszenario.prj_projekte_id = prj.zeige__strstrkt.prj_projekte_id 9307 AND 9308 -- 9309 -- -- Gefahrenszenario auswählen ---------------------------------- 9310 -- 9311 prj.zeige__pl_prtpsgefszenario.ps_gefszenario_id = """ + str( self.ps_gefszenario_id ) + """ 9312 ORDER BY 9313 prj.zeige__strstrkt.str__name__id 9314 , strpkt 9315 ;""" ) 9316 9317 9318 9319 # 9320 # -- es sind keine Dokumente darzustellen ---------------------------------- 9321 # 9322 if( self.__gibAnzZeilen__() == 0 ) : return 9323 9324 9325 9326 # 9327 # -- Strukturpunkte übernehmen ------------------------------------------ 9328 # 9329 nameHauptKnoten = '' 9330 for i in range( self.__gibAnzZeilen__() ): 9331 9332 # 9333 # -- Neuen Hauptknoten übernehmen ---------------------------------- 9334 # 9335 if( nameHauptKnoten != self.__gibWert__( i, 3 ) ) : 9336 9337 nameHauptKnoten = self.__gibWert__( i, 3 ) 9338 9339 TreeCtrlErg.nimmHauptknoten( wert = nameHauptKnoten, bezHK = HK_STR ) 9340 9341 9342 # 9343 # -- ---------------------------------- 9344 # -- Strukturpunkt übernehmen ---------------------------------- 9345 # -- ---------------------------------- 9346 # -- [0] strpkt ------------------ 9347 # -- [1] prj.zeige__strstrkt.str__strkt__id ------------------ 9348 # -- [2] nachfok.str__strkt__id AS str_strkt_id__vorg ------------------ 9349 # -- [3] prj.zeige__strstrkt.str__name__name_k ------------------ 9350 # -- [4] prj.zeige__strstrkt.str__name__id ------------------ 9351 # -- ------------------ 9352 # 9353 clientData = [ self.__gibWert__( i, 1 ) ] 9354 clientData.append( None ) 9355 clientData.append( self.__gibWert__( i, 3 ) ) 9356 9357 TreeCtrlErg.nimmWert( wert = self.__gibWert__( i, 0 ) 9358 , wertId = None 9359 , dbId = self.__gibWert__( i, 1 ) 9360 , wertIdVorgaenger = self.__gibWert__( i, 2 ) 9361 , clientData = clientData )

9362 9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374 # 9375 # ------------------------------------------------------------------------------------ 9376 # ------------------------------------------------------------------------------------ 9377 # -- Strukturpunkte selektieren ---------------------------------- 9378 # -- Sicht >prj.zeige__strstrkt< selektieren ---------------------------------- 9379 # ------------------------------------------------------------------------------------ 9380 # ------------------------------------------------------------------------------------ 9381 #

9382 - def selektiere__strStrkt__Projekt__Sprache( self, TreeCtrlErg, strNameId = None, strStrktId = None ) :

9383 """ 9384 Methode zur Darstellung der Strukturpunkte. ACHTUNG, Das Gefahrennetz wird nicht dargestellt ! 9385 9386 @note: Die übergebene Baumstruktur (C{TreeCtrlErg}) wird verändert ! 9387 9388 @param TreeCtrlErg: Es ist die Baumstruktur zu übergeben, die die Strukturpunkte aufnimmt. 9389 @type TreeCtrlErg: TreeCtrlErg 9390 9391 @param strNameId: Es ist die Datenbankidentifikationsnummer (C{str.name.id}) der Strukturbezeichnung zu übergeben, die dargestellt werden soll. Sie darf auch C{None} sein. 9392 @type strNameId: list (Ganzzahl) 9393 9394 @param strStrktId : Es sind die Struktur-Id C{str.strkt.id} zu übergeben. Darf auch C{None} sein. 9395 @type strStrktId : C{list (Ganzzahl)} 9396 """ 9397 9398 # 9399 # -- es sind keine Strukturpunkte darzustellen -------------------------- 9400 # 9401 if( len( self.daten__strStrkt__Projekt__Sprache ) == 0 ) : return 9402 9403 9404 9405 # 9406 # -- Strukturpunkte übernehmen ------------------------------------------ 9407 # -- ------------------ 9408 # -- [0] strpkt ------------------ 9409 # -- [1] prj.zeige__strstrkt.str__strkt__id ------------------ 9410 # -- [2] nachfok.str__strkt__id AS str_strkt_id__vorg ------------------ 9411 # -- [3] prj.zeige__strstrkt.str__name__name_k ------------------ 9412 # -- [4] prj.zeige__strstrkt.str__name__id ------------------ 9413 # 9414 nameHauptKnoten = '' 9415 for i in range( len( self.daten__strStrkt__Projekt__Sprache ) ): 9416 9417 # 9418 # -- Gefahrennetz ignorieren ---------------------------------- 9419 # 9420 if( self.daten__strStrkt__Projekt__Sprache[i][4] == self.konstante__str_name_id__gefahrennetz ) : 9421 9422 continue 9423 9424 9425 9426 # 9427 # -- nach Strukturnamen selektieren ---------------------------------- 9428 # 9429 if( strNameId is not None 9430 and self.daten__strStrkt__Projekt__Sprache[i][4] not in strNameId ) : 9431 9432 continue 9433 9434 9435 9436 # 9437 # -- nach Strukturpunkten selektieren -------------------------- 9438 # 9439 if( strStrktId is not None 9440 and self.daten__strStrkt__Projekt__Sprache[i][1] not in strStrktId ) : 9441 9442 continue 9443 9444 9445 9446 # 9447 # -- Neuen Hauptknoten übernehmen ---------------------------------- 9448 # 9449 if( nameHauptKnoten != self.daten__strStrkt__Projekt__Sprache[i][3] ) : 9450 9451 nameHauptKnoten = self.daten__strStrkt__Projekt__Sprache[i][3] 9452 9453 TreeCtrlErg.nimmHauptknoten( wert = nameHauptKnoten, bezHK = HK_STR ) 9454 9455 9456 # 9457 # -- Strukturpunkt übernehmen ---------------------------------- 9458 # 9459 clientData = [ self.daten__strStrkt__Projekt__Sprache[i][1] ] 9460 clientData.append( None ) 9461 clientData.append( self.daten__strStrkt__Projekt__Sprache[i][3] ) 9462 9463 TreeCtrlErg.nimmWert( wert = self.daten__strStrkt__Projekt__Sprache[i][0] 9464 , wertId = None 9465 , dbId = self.daten__strStrkt__Projekt__Sprache[i][1] 9466 , wertIdVorgaenger = self.daten__strStrkt__Projekt__Sprache[i][2] 9467 , clientData = clientData )

9468 9469 9470 9471 9472 # 9473 # ------------------------------------------------------------------------------------ 9474 # ------------------------------------------------------------------------------------ 9475 # -- PostgreSQL-Safepoint setzen ------------------------------------------ 9476 # ------------------------------------------------------------------------------------ 9477 # ------------------------------------------------------------------------------------ 9478 #

9479 - def setzeSafepoint( self, name ):

9480 """ 9481 Methode zum setzen eines C{PostgreSQL - Safepoints}. Mittels C{Safepoint} können Teile einer Transaktion gespeichert oder verworfen werden. 9482 9483 @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. 9484 @type name: Zeichenkette 9485 """ 9486 9487 # 9488 # -- in Protokolldatei schreiben ------------------------------------------ 9489 # 9490 self.ProtokolldateiEintragen( eintrag = "setzeSafepoint()" 9491 , istKopfzeile = True ) 9492 9493 9494 9495 # 9496 # -- vorsichtshalber einen neuen Cursor anlegen -------------------------- 9497 # 9498 self.dbCursor = self.dbVerbindung.cursor() 9499 9500 # 9501 # -- SAFEPOINT setzen -------------------------------------------------- 9502 # 9503 self.__dbAbfrage__( 'SAVEPOINT ' + name + ';' ) 9504 9505 # 9506 # -- vorsichtshalber einen neuen Cursor anlegen -------------------------- 9507 # 9508 self.dbCursor = self.dbVerbindung.cursor()

9509 9510 9511 # 9512 # ------------------------------------------------------------------------------------ 9513 # ------------------------------------------------------------------------------------ 9514 # -- Änderungen verwerfen (aktuelle Transaktion schließen, ------------------ 9515 # -- neue Transaktion starten) ------------------ 9516 # ------------------------------------------------------------------------------------ 9517 # ------------------------------------------------------------------------------------ 9518 #

9519 - def verwerfeAenderungen( self ):

9520 """ 9521 Es werden alle Änderungen verworfen (der alte Datenbankzustand hergestellt), die laufende Transaktion beendet und eine neue Transaktion gestartet. 9522 """ 9523 9524 # 9525 # -- in Protokolldatei schreiben ------------------------------------------ 9526 # 9527 self.ProtokolldateiEintragen( eintrag = "verwerfeAenderungen() --> ROLLBACK" 9528 , istKopfzeile = True ) 9529 9530 9531 9532 # 9533 # -- Änderungen verwerfen, Transaktion starten -------------------------- 9534 # 9535 self.dbVerbindung.rollback()

9536 9537 9538 9539 9540 9541 # 9542 # ------------------------------------------------------------------------------------ 9543 # ------------------------------------------------------------------------------------ 9544 # -- Alle Änderungen seit Setzen eines PostgreSQL-Safepoints verwerfen -- 9545 # ------------------------------------------------------------------------------------ 9546 # ------------------------------------------------------------------------------------ 9547 #

9548 - def verwerfeAenderungenSafepoint( self, name ):

9549 """ 9550 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. 9551 9552 @param name: Es ist der Name des C{Safepoints} anzugeben. 9553 @type name: Zeichenkette 9554 """ 9555 9556 # 9557 # -- in Protokolldatei schreiben ------------------------------------------ 9558 # 9559 self.ProtokolldateiEintragen( eintrag = "verwerfeAenderungenSafepoint()" 9560 , istKopfzeile = True ) 9561 9562 9563 9564 # 9565 # -- vorsichtshalber einen neuen Cursor anlegen -------------------------- 9566 # 9567 self.dbCursor = self.dbVerbindung.cursor() 9568 9569 # 9570 # -- bis zum SAFEPOINT zurückrollen ------------------------------------------ 9571 # 9572 self.__dbAbfrage__( 'ROLLBACK TO SAVEPOINT ' + name + ';' ) 9573 9574 # 9575 # -- vorsichtshalber einen neuen Cursor anlegen -------------------------- 9576 # 9577 self.dbCursor = self.dbVerbindung.cursor()

Source Code for Module datenbank