Ankündigung

Einklappen
Keine Ankündigung bisher.

PHP Website mit pdo, ohne try -c.

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • PHP Website mit pdo, ohne try -c.

    Ich habe unter folgendem Link eine Super-Klasse (die von zwei Sub-Klassen angesteuert wird) hochgeladen.
    Könnt ihr es kurz ansehen und mir Tipps geben ? Ich habe auf sql injection geachtet, mit pdo programmiert und try-catch nicht verwendet. Kommt noch..

    https://gist.github.com/4522932

  • #2
    Schon nach der ersten Zeile kann ich dir sagen: Nein, das geht einfach nicht.

    global $objSmarty;

    Du benutzt ein Singleton, um die Datenbank abzulegen.

    Mischung PDO/MySQL-Extension...

    Das Ganze ist eine Gott-Klasse: Das Programm wird dort erst wirklich gestartet, dort ausgeführt und dort wird auch der Output generiert.

    Kommentar


    • #3
      Schreibe keine Methoden, die 311 Zeilen lang sind.

      Du hast eine Klasse SuperCA mit den Methoden:

      - lists
      - printToFile
      - downloadFiles
      - downloadWeb

      Keine der Methoden nimmt Parameter entgegen.

      Ich kann damit nicht wirklich viel anfangen. Warum ist eine Klasse für all das zuständig? Was tun Methoden, die „auflisten“ und die ein „Web herunterladen“?

      Die Beschreibung spricht da Bände:

      Prepares a table or form with one to several rows and columns from database for printing in smarty. Select Query is this->sQuery. Two arrays are created: the field/title array(lines 42 - 107) and the content array (lines 111 onwards). There are two sub classes: a) List: preparing a list with Where Statements b) One Entry: preparing the edit/create form
      Oder auch nicht.

      Du nutzt zudem überall statische Methodenaufrufe statt etwa Dependency Injection. Was ich an Code sehe, kommt mir auch zu großen Teilen „hardgecodet“ vor, also speziell für einen einzigen Anwendungsfall angelegt.

      Sorry, wenn ich das offen sage, aber du scheinst Objektorientierung (Sichtbarkeiten, Kapselung, Schnittstellen) nicht verstanden zu haben, sondern deinen Code nur mehr oder weniger willkürlich in „Klassen“ und „Methoden“ zu unterteilen, die du dir dann etwa mit globalen Variablen und statischen Aufrufen so zurechtbastelst, dass du überall Zugriff auf beliebige, von deinem Code gerade benötigte Variablen und Funktionen hast.

      Erklär vielleicht noch mal genauer, welche Funktionalität du implementieren möchtest. Dann können wir Vorschläge machen.

      Kommentar


      • #4
        Zitat von UbuntuEmacs Beitrag anzeigen
        Ich habe auf sql injection geachtet, mit pdo programmiert und try-catch nicht verwendet.
        Was ist daran besonders positiv/gut, try catch nicht zu verwenden? [Wird sogar explizit im Titel nochmal erwähnt]

        Kommentar


        • #5
          Denke, das hat er als Punkt angeführt, bei dem er weiß, dass der noch fehlt.

          @UbuntuEmacs: Aber wie in meinem Edit gesagt (vielleicht nicht gesehen): Erklär vielleicht noch mal genauer, welche Funktionalität du implementieren möchtest. Dann können wir Vorschläge machen.

          Gut wäre dabei vielleicht, auch die beteiligten Komponenten erst mal anzuführen. Du hast etwa ein Smarty, dann irgendeine Datenbankklasse, … usw.

          Edit: Der Code ist anfällig für SQL-Injections. Und nutze Instanzen, keine statischen Aufrufe!

          Edit2: Noch einige Notizen:

          PHP-Code:
          $sFieldName[0][$i] = mysql_field_name($sql, $i); 
          Ungarisches Notationseigentor.

          Kommentar


          • #6
            Ich würde mich auch an Post #3 anschliessen. Methoden, die rund 300 Zeilen lang sind, sind zu mächtig. Das kannst du aufteilen und dank dem, dass man Methoden auch als protected markieren kann, ergibt das auch keine Zugriffsfehler.

            Zudem wird in dieser Klasse wirklich zu viel zusammengeführt. Das solltest du aufteilen.

            Kommentar


            • #7
              Was hat denn jetzt protected damit zu tun?

              Kommentar


              • #8
                Die Sub-Klassen werden weiterhin funktionieren und die ausgelagerte Logik ist von "extern" nicht erreichbar. Ich denke das war gemeint.

                Kommentar


                • #9
                  Genau das war gemeint.

                  Kommentar


                  • #10
                    Die Frage ist also : wie wird objektorientierung(oo) auf eine auftragsverwaltung mit mehreren Tabellen (Aufträge, Personen, Orte) angewandt.

                    IST
                    Momentan wird eine Methode geladen (willkürlich, über index), in der Methode wird dann auf die DB zugeriffen per insert, select, delete, etc. und zwar prozedural. Es gibt Hilfsmethoden (wie z.b. is_id, oder fetch_PDO) die statisch aufgerufen werden.

                    SOLL
                    Wahrsheinlich muss ich die oo auf die db direkt anwenden, also so:
                    Es wird die Index gestartet. Sobald auf die Datenbank zugegriffen wird, wird ein Objekt erzeugt. Sollte ein select - Zugriff mit Ausgabe erfolgen, wird zusätzlich auf das smarty objekt zugegriffen um die Ausgabe zu erzeugen.

                    REALISIERUNG
                    Sollte ich also eine Select-, Insert, Update Klasse haben ? Wie sind in diesem Zusammenhang die PDO-Klassen zu sehen ?

                    Wie soll das Projekt struktuiert sein ?

                    FRAGEN
                    Praktischer Teil:
                    Wieso geht es nicht, in einem Array an der nullten Stelle über alle Felder mysql_field_name zu speichern ("Ungarische Notation").
                    Wieso ist global Smarty nicht gut, ist
                    PHP-Code:
                    $objSmarty = new Smarty();
                    # $objSmarty->caching = true; # Habe damit keine guten Erfahrungen gemacht.
                    $objSmarty->cache_lifetime = 7600; # Sekunden--> über 2 Stunden
                    # falls Änderung, wird neu kompiliert trotz Caching
                    $objSmarty->compile_check = true;
                    $objSmarty -> template_dir = 'smarty/templates/';
                    $objSmarty -> compile_dir = 'smarty/templates_c/'; 
                    besser in jeder Methode, die mit Select etwas ausgibt? Globale Variablen sollen ja nicht verwendet werden, weil unsauber.

                    Sollte ich statt Singleton besser das machen:
                    PHP-Code:
                     class Singleton
                      
                    {
                          static private 
                    $instances = array();
                      
                          static public function 
                    getInstance($className)
                          {
                              if (!isset(
                    self::$instances[$className])) {
                                 
                    self::$instances[$className] = new $className();
                            }
                            return 
                    self::$instances[$className];
                        }
                     }
                     require_once 
                    'DBZugang1.php';
                     
                    $DBZugang1= Singleton::getInstance('DBZugang1');
                     require_once 
                    'DBZugang2.php';
                     
                    $DBZugang2= Singleton::getInstance('DBZugang2'); 
                    Wobei DBZugang1 mein remote Webserver ist, und DBZugang2 der lokale ? Hier könnten dann beliebige weitere DBs dazukommen. Wo speichere ich hostnamen etc. ?

                    Kommentar


                    • #11
                      Statt globals und Singletons anzuwenden, solltest du dich mit Dependency Injection auseinandersetzen.

                      Kommentar


                      • #12
                        Zitat von UbuntuEmacs Beitrag anzeigen
                        Sollte ich statt Singleton besser das machen:
                        PHP-Code:
                         class Singleton
                          
                        {
                              static private 
                        $instances = array();
                          
                              static public function 
                        getInstance($className)
                              {
                                  if (!isset(
                        self::$instances[$className])) {
                                     
                        self::$instances[$className] = new $className();
                                }
                                return 
                        self::$instances[$className];
                            }
                         } 
                        Wo der Unterschied zwischen einem Singleton(ohne E ) und dieser Klasse (mit zufälliger Namensähnlichkeit) ist, musst du mir erklären.

                        Kommentar


                        • #13
                          Das nennt man relativ oft ein Multiton und ist vom Prinzip her genau dasselbe.

                          Kommentar


                          • #14
                            Zitat von Asterixus Beitrag anzeigen
                            Das nennt man relativ oft ein Multiton und ist vom Prinzip her genau dasselbe.
                            Das ist das, was ich damit sagen wollte...

                            Kommentar


                            • #15
                              Habe mal ein wenig dran rumgebastelt. Die Version ist so nicht lauffähig (konnte es nicht sinnvoll testen), aber zur Verdeutlichung einer möglichen Strukturierung soll es wohl taugen.

                              index.php:

                              PHP-Code:
                              <?php

                              interface ApplicationContextInterface
                              {
                                  public function 
                              createNewView();
                                  public function 
                              getPdo();
                              }

                              class 
                              ApplicationContext implements ApplicationContextInterface
                              {
                                  protected 
                              $pdo = null;

                                  public function 
                              createNewView()
                                  {
                                      return new 
                              Smarty();
                                  }

                                  public function 
                              getPdo()
                                  {
                                      if (
                              $this->pdo === null) {
                                          
                              $this->pdo = new PDO('...');
                                      }

                                      return 
                              $this->pdo;
                                  }
                              }



                              $applicationContext = new ApplicationContext();



                              if (
                              $_GET['component'] === 'mycomponent') {
                                  
                              $controller = new MyComponentController($applicationContext);

                                  if (
                              $_GET['action'] === 'list') {
                                      
                              $controller->listAction();
                                  }
                              }
                              MyComponentController.php:

                              PHP-Code:
                              <?php

                              /**
                               *
                               *
                               * Zu Methoden dieser Klasse werden eingehende Requests, für die die Komponente
                               * zuständig ist, geleitet (Routing). Die Klasse instanziiert eine (oder
                               * mehrere) Model-Klassen, ruft benötigte Methoden auf und weist
                               * zurückgelieferte Daten einer geeigneten Ausgabe-Komponente zu.
                               *
                               * Globale Komponenten (etwa die DB-Verbindung oder eine Factory für
                               * View-Instanzen) habe ich hier als ApplicationContext als
                               * Konstruktor-Abhängigkeit implementiert. Es gibt andere Wege (Vererbung etwa).
                               * Die Klasse soll verdeutlichen, dass es auch für den Controller noch eine
                               * übergeordnete Ebene gibt (Application, Front-Controller), auf der
                               * grundlegende Komponenten instanziiert werden.
                               *
                               * Diese Klasse kennt (im Gegensatz zur Model-Klasse) Request-Daten, die
                               * superglobalen Arrays ($_GET, $_POST, ...).
                               */
                              class MyComponentController
                              {
                                  
                              /**
                                   *
                                   * @var ApplicationContextInterface
                                   */
                                  
                              protected $applicationContext;

                                  
                              /**
                                   *
                                   * @var MyComponentModel
                                   */
                                  
                              protected $model;

                                  
                              /**
                                   *
                                   * @var Smarty
                                   */
                                  
                              protected $view;

                                  
                              /**
                                   *
                                   */
                                  
                              public function __construct(ApplicationContextInterface $applicationContext)
                                  {
                                      
                              $this->applicationContext = $applicationContext;

                                      
                              $this->init();
                                  }

                                  
                              /**
                                   *
                                   */
                                  
                              protected function init()
                                  {
                                      
                              $this->model = new MyComponentModel(
                                          
                              $this->applicationContext->getPdo()
                                      );

                                      
                              $this->view = $this->applicationContext->createNewView();
                                  }

                                  
                              /**
                                   *
                                   * @param ListDataContainer $data
                                   */
                                  
                              protected function listAction_assignDataToView(ListDataContainer $data)
                                  {
                                      
                              $this->view->assign('Actions', $data->aActions);

                                      
                              // Beide: Update und Liste
                                      
                              $this->view->assign('Checkbox', $data->aCheckbox);

                                      
                              // vorauswahl stadt, update
                                      
                              $this->view->assign('City', $data->aCity);

                                      
                              //nach Auswahl Werk --> komponist
                                      
                              $this->view->assign('ComposerSelected', $data->aComposerSelected);

                                      
                              // Feldinhalt
                                      
                              $this->view->assign('Content', $data->aRowContent);

                                      
                              // Feldtitel für Liste
                                      
                              $this->view->assign('FieldHead', $data->aFieldHead);
                                      
                              $this->view->assign('FieldHead2dim', $data->FieldHead2Dim);
                                      
                              $this->view->assign('FieldName', $data->sFieldName);

                                      
                              // update
                                      
                              $this->view->assign('FieldType', $data->aFieldType);

                                      
                              // update
                                      
                              $this->view->assign('FieldZip', $data->bFieldZip);

                                      
                              // dreidimensionales Array Dropdown List
                                      
                              $this->view->assign('LinkedAll', $data->aLinkedAll);

                                      
                              // vierdimensionales Array update
                                      
                              $this->view->assign('LinkedAll4Dim', $data->aLinkedAll2);

                                      
                              $this->view->assign('Line', $data->Line);

                                      
                              // Dropdown Update
                                      
                              $this->view->assign('NumberFields', $data->nNumberFields);

                                      
                              // beide
                                      
                              $this->view->assign('Tables', $data->aTablesMenu);

                                      
                              // eindimensionales Array Überschrift, beide
                                      
                              $this->view->assign('TablesLinked', $data->aTablesLinked);

                                      
                              // zweidimensionales A., nur update
                                      
                              $this->view->assign('TablesLinked2Dim', $data->aTablesLinked2Dim);

                                      
                              // list
                                      
                              $this->view->assign('TablesLinkedList', $data->aTablesLinkedList);

                                      
                              // update, nach Auswahl Komponist aWorkName
                                      
                              $this->view->assign('Work', $data->aWork);

                                      
                              // Nach Auswahl Stadt
                                      
                              $this->view->assign('Zip', $data->aZip);
                                  }

                                  
                              /**
                                   *
                                   * @param bool $frontend
                                   * @return string
                                   */
                                  
                              protected function listAction_chooseTemplateFile($frontend)
                                  {
                                      
                              $templateFile = 'list.tpl';

                                      if (
                              $frontend) {
                                          
                              // homepage
                                          
                              switch ($this->sTable) {
                                              case 
                              'musiker':
                                                  
                              $templateFile = 'frontend/viewDetailMusician.tpl';
                                                  break;
                                              default:
                                                  
                              $templateFile = 'frontend/viewDetailSolCond.tpl';
                                                  break;
                                          }
                                      } elseif (
                                          
                              $this->sTable === 'programm'
                                          
                              || $this->sTable === 'programmwerk'
                                          
                              || $this->sTable === 'komponist'
                                      
                              ) {
                                          
                              // update or create
                                          
                              $templateFile = 'editProgramme.tpl';
                                      } elseif (
                              $this->nId or $this->bNewEntry){
                                           
                              // update or create
                                          
                              $templateFile = 'edit.tpl';
                                      }

                                      return 
                              $templateFile;
                                  }

                                  
                              /**
                                   *
                                   */
                                  
                              public function printAction()
                                  {
                                      
                              $data = $this->model->getDataForPrintAction('test', 2);

                                      
                              // header ist scharf: Davor darf keine Meldung, etc. geschrieben werden
                                      
                              header('Content-Type: application/doc');
                                      
                              header('Content-Disposition: attachment; filename="Biografie'
                                          
                              . $data['name'] . '.doc"');

                                      echo 
                              $data['name'] . '\n\n';
                                      echo 
                              $data['content'];
                                  }

                                  
                              /**
                                   *
                                   */
                                  
                              public function downloadAction()
                                  {
                                      
                              $data = $this->model->getDataForDownloadAction();

                                      
                              $wordSplitted = explode('::', __METHOD__);
                                      
                              $templateFile = 'frontend/' . $wordSplitted[1] . 'tpl';

                                      
                              $this->view->assign($data);
                                      
                              $this->view->display($templateFile);
                                  }

                                  
                              /**
                                   *
                                   */
                                  
                              public function listAction()
                                  {
                                      
                              $listDataParams = new ListDataParams(
                                          isset(
                              $_REQUEST['SelectComposer'])
                                              ? (int) 
                              $_REQUEST['SelectComposer']
                                              : 
                              null,
                                          isset(
                              $_REQUEST['SelectCity'])
                                              ? (string) 
                              $_REQUEST['SelectCity']
                                              : 
                              null
                                      
                              );

                                      
                              $data = $this->model->getDataForListAction($listDataParams);

                                      
                              $templateFile = $this->listAction_chooseTemplateFile(
                                          isset(
                              $_REQUEST['Frontend'])
                                      );

                                      
                              $this->listAction_assignDataToView($data);
                                      
                              $this->view->display($templateFile);
                                  }
                              }
                              MyComponentModel.php:

                              PHP-Code:
                              <?php

                              /**
                               *
                               *
                               * Diese Klasse kennt Smarty (die View-Komponente) nicht und kennt auch nicht
                               * den Controller. Sie dient dazu, auf das Storage-Backend zuzugreifen und
                               * gegebenenfalls notwendige Geschäftslogik durchzuführen.
                               *
                               * Abhängigkeiten, die nicht im Interface auftauchen (nicht von außerhalb
                               * geliefert werden): HelpFunc
                               *
                               * Am besten in MyComponentController eine Instanz von HelpFunc erzeugen und
                               * diese als Konstruktorparameter an diese Klasse übergeben.
                               */
                              class MyComponentModel
                              {
                                  
                              /**
                                   * Tabellen-Array links im Menü, für beide
                                   *
                                   * @var string
                                   */
                                  
                              protected $sQuery = "
                                      SELECT
                                              `Tables`
                                      FROM
                                              `Tables`
                                      WHERE
                                              `online` = 1
                                      ORDER BY
                                              `Tables`
                                  "
                              ;

                                  
                              /**
                                   *
                                   * @var string
                                   */
                                  
                              protected $OrderMonth = '';

                                  
                              /**
                                   *
                                   * @var type
                                   */
                                  
                              protected $OrderYear = '';

                                  
                              /**
                                   *
                                   * @var string
                                   */
                                  
                              protected $sId = '';

                                  
                              /**
                                   *
                                   * @var bool
                                   */
                                  
                              protected $bNewEntry = false;

                                  
                              /**
                                   *
                                   * @var int
                                   */
                                  
                              protected $nId = 0;

                                  
                              /**
                                   *
                                   * @var string
                                   */
                                  
                              protected $sTable = '';

                                  
                              /**
                                   *
                                   * @var PDO
                                   */
                                  
                              protected $pdo;

                                  
                              /**
                                   *
                                   * @var ListDataParams
                                   */
                                  
                              protected $listDataParams = null;

                                  
                              /**
                                   *
                                   * @param PDO $pdo
                                   */
                                  
                              public function __construct(PDO $pdo)
                                  {
                                      
                              $this->pdo = $pdo;
                                  }

                                  
                              /**
                                   * Returns whether this instance is an update instance
                                   *
                                   * @return bool
                                   */
                                  
                              protected function isUpdate()
                                  {
                                      return (
                              $this->nId || $this->bNewEntry);
                                  }

                                  
                              /**
                                   *
                                   * Unterschiedliche Id-Namen (programmWerk hier nicht, da nicht
                                   * auf sie verwiesen wird)
                                   *
                                   * @param string $sTableName
                                   */
                                  
                              protected function setIdStringByTableName($sTableName)
                                  {
                                      
                              $this->sId = 'id';

                                      if (
                              $sTableName === 'komponist') {
                                          
                              $this->sId = 'komponist_Id';
                                      } elseif (
                              $sTableName === 'programm') {
                                          
                              $this->sId = 'programm_Id';
                                      }
                                  }

                                  
                              /**
                                   * Unterschiedliche erste Spaltenbezeichnung (Name)
                                   *
                                   * @param string $sTableName
                                   * @return string
                                   */
                                  
                              protected function getFirstColumnByTableName($sTableName)
                                  {
                                      
                              $sFirstColumn = $sTableName;

                                      if (
                                          
                              $sTableName === 'musiker'
                                          
                              || $sTableName === 'dirigent'
                                          
                              || $sTableName === 'solist'
                                      
                              ) {
                                          
                              $sFirstColumn = "artist";
                                      }

                                      return 
                              $sFirstColumn;
                                  }

                                  
                              /**
                                   * verknüpfte Tabellennamen mit allen Zeilen (Liste-überschrift und
                                   * create/update)
                                   */
                                  
                              protected function connectXy(
                                      
                              ListDataContainer $data,
                                      
                              $fieldName,
                                      
                              $i
                                  
                              ) {
                                      
                              $aTableName = explode('_id', $fieldName);
                                      
                              $sTableName = $aTableName[0];

                                      
                              $sWhere = '';

                                      
                              // WHERE Selektion mit Zeit einfügen
                                      
                              if ($this->OrderMonth) {
                                          
                              $sWhere = '
                                              WHERE MONTH(konzertdatum) = '
                              . $this->OrderMonth.'
                                              and YEAR(konzertdatum) = '
                              . $this->OrderYear;
                                      }

                                      
                              $this->setIdStringByTableName($sTableName);

                                      
                              $sFirstColumn = $this->getFirstColumnByTableName($sTableName);

                                      
                              // Fallunterscheidung: alle Datensätze für create und update
                                      // oder nur ein Datensatz für read
                                      
                              if ($this->isUpdate()) {
                                          
                              // Update oder Create
                                          
                              $sQuery = "
                                              SELECT DISTINCT 
                              $this->sId, $sFirstColumn
                                              FROM 
                              $sTableName
                                              ORDER BY 
                              $sFirstColumn";
                                      } else {
                                          
                              // durch join nur die Datensätze, die in Tabelle vorkommen
                                          // (Read)
                                          
                              $sQuery = "
                                              SELECT DISTINCT " 
                              . $sTableName . "." . $this->sId
                                              
                              . ", " . $sFirstColumn." FROM ". $sTableName
                                              
                              . " JOIN ". $this->sTable
                                              
                              . " On ".$this->sTable.".". $sTableName."_id = "
                                              
                              . $sTableName. ".".$this->sId." "
                                              
                              . $sWhere
                                              
                              ." ORDER BY ". $sFirstColumn;
                                      }

                                      
                              $sth3 = $this->pdo->prepare($sQuery);
                                      
                              $sth3->execute();
                                      
                              $data->aLinkedAll[$i] = $sth3->fetchAll(PDO::FETCH_NUM);

                                      
                              $data->aLinkedAll2[0][$i] = $data->aLinkedAll[$i];

                                      
                              // Überschrift Liste
                                      
                              $data->aTablesLinked[$i] = $sTableName;

                                      
                              // überschrift zweidimensional create/update
                                      
                              $data->aTablesLinked2Dim[0][$i] = $sTableName;
                                  }

                                  
                              /**
                                   *
                                   */
                                  
                              protected function doThingieOne(
                                      
                              ListDataContainer $data,
                                      
                              $sql
                                  
                              ) {
                                      
                              $sFieldName = array();

                                      
                              $i = 0;

                                      
                              // 1. Schleife für Überschriften, wird nur einmal durchlaufen
                                      
                              while ($i < $data->nNumberFields) {
                                          
                              // Datentyp im create/update-Bereich
                                          
                              $sFieldName[0][$i] = mysql_field_name($sql, $i);

                                          if (
                              false !== strpos(mysql_field_name($sql, $i), '_id')) {
                                              
                              $this->connectXy($data, mysql_field_name($sql, $i), $i);
                                          } else {
                                              
                              // Feldüberschrift für Create
                                              
                              if ($this->bNewEntry) {
                                                  
                              $data->FieldHead2Dim[0][$i] = mysql_field_name($sql, $i);
                                              }

                                              
                              $data->aFieldHead[$i] = mysql_field_name($sql, $i);
                                          }

                                          
                              $i++;
                                      }
                                  }

                                  
                              /**
                                   *
                                   */
                                  
                              protected function doThingieTwo(
                                      
                              ListDataContainer $data,
                                      
                              $sql,
                                      
                              ListDataParams $params
                                  
                              ) {
                                      
                              // Werte anzeigen

                                      //$sLimit = '';
                                      //$nComposerId = 0;

                                      
                              $l = 0;

                                      while (
                              $aLine = mysql_fetch_row($sql)) {
                                          
                              // Aktionen links anzeigen
                                          
                              $actionLinks = array();

                                          
                              $actionLinks[] = 'index.php?'
                                              
                              . http_build_query(array(
                                                  
                              'class'  => 'OrderProgramme',
                                                  
                              'action' => 'QueryOrder',
                                                  
                              'Id'     => $aLine[0])
                                              )
                                              . 
                              ' target="_blank">Programm';

                                          
                              $actionLinks[] = 'index.php?'
                                              
                              . http_build_query(array(
                                                  
                              'class'  => 'Contract',
                                                  
                              'action' => 'QueryOrder',
                                                  
                              'Id'     => $aLine[0])
                                              )
                                              . 
                              ' target="_blank">Auftrag';

                                          
                              $actionLinks[] = 'index.php?'
                                              
                              . http_build_query(array(
                                                  
                              'class'  => 'Invoice',
                                                  
                              'action' => 'QueryOrder',
                                                  
                              'Id'     => $aLine[0])
                                              )
                                              . 
                              ' target="_blank">Rechnung';

                                          
                              $data->aActions[] = $actionLinks;

                                          for (
                              $i = 0; $i < $data->nNumberFields; $i++) {
                                              if (
                              $this->nId) {
                                                  
                              // Unterschied im Schlüssel: für Update-Create-bereich
                                                  
                              $data->FieldHead2Dim[0] = $data->aFieldHead;
                                              } else {
                                                  
                              // für Read
                                                  
                              $data->FieldHead2Dim[$i] = $data->aFieldHead;
                                              }

                                              
                              // zweidimensionales Array mit Tabellenwerten vorhanden falls
                                              // kein neuer Eintrag
                                              
                              if ($this->bNewEntry === false) {
                                                  
                              // Inhalt geladen
                                                  
                              $data->aRowContent[$l][$i] = $aLine[$i];
                                              }

                                              
                              // Abfrage hier und nicht bei oneentry, da hier werk_id von
                                              // aLine
                                              
                              if (
                                                  
                              mysql_field_name($sql, $i) === 'werk_id'
                                                  
                              && $this->isUpdate()
                                              ) {
                                                  
                              // programmwerk oder auftrag und update/Create
                                                  // 3 Abfragen:
                                                  //   a) alle Komponisten (bereits in oneentry),
                                                  //   b) Werke von ausgewähltem Komponist,
                                                  //   c) Komponist zu Werk

                                                  //--------------b)-------------
                                                  
                              $sLimit = 'LIMIT 20';
                                                  
                              $sWhere = '';

                                                  
                              // Komponist ausgewählt, Sicherheitsüberprüfung ID
                                                  
                              if (
                                                      
                              $params->selectComposer !== null
                                                      
                              && HelpFunc::is_id($params->selectComposer)
                                                  ) {
                                                      
                              // Komponist aus Auswahl
                                                      
                              $nComposerId = $params->selectComposer;
                                                      
                              $sWhere = " WHERE komponist_id = $nComposerId ";
                                                  } elseif (
                              $aLine[$i]) {
                                                      
                              $sWhere = " WHERE id = $aLine[$i]";
                                                      
                              $sLimit = ' LIMIT 1';
                                                  }

                                                  if (
                              $nComposerId || $aLine[$i]) {
                                                      
                              // dann wird nach Werken gesucht
                                                      
                              $sQuery2 = "
                                                          SELECT id, werk
                                                          FROM werk 
                              $sWhere
                                                          ORDER BY werk 
                              $sLimit";

                                                      
                              $sth5 = $this->pdo->prepare($sQuery2);
                                                      
                              $sth5->execute();
                                                      
                              $aWork = $sth5->fetchAll(PDO::FETCH_ASSOC);

                                                      
                              //------------c) ---------------
                                                      //Werk vorhanden, dann Komponist anzeigen
                                                      
                              $nPieceId = $aWork[0]['id'];
                                                      
                              $sQuery3 = "
                                                          Select komponist.komponist_Id, komponist
                                                          from komponist
                                                              JOIN werk
                                                              ON werk.komponist_id = komponist.komponist_Id
                                                          WHERE werk.id = 
                              $nPieceId
                                                          LIMIT 1"
                              ;

                                                      
                              $sth6 = $this->pdo->prepare($sQuery3);
                                                      
                              $sth6->execute();

                                                      
                              // Fetch all of the remaining rows in the result set
                                                      
                              $data->aComposerSelected = $sth6->fetch(
                                                          
                              PDO::FETCH_ASSOC
                                                      
                              );
                                                  }
                                              } elseif (
                              mysql_field_name($sql, $i) === 'PLZOrt_id') {
                                                  
                              // PLZOrt = PLZ; mehrere Tabellen mit Orten, update oder
                                                  // Create als Bedingung

                                                  // Alle Orte-Array
                                                  
                              $data->bFieldZip = true;
                                                  
                              $sQuery3 = "
                                                      SELECT DISTINCT Ort
                                                      FROM PLZOrt
                                                      ORDER BY Ort"
                              ;

                                                  
                              $sth7 = $this->pdo->prepare($sQuery3);
                                                  
                              $sth7->execute();
                                                  
                              $data->aCity = $sth7->fetchAll(PDO::FETCH_ASSOC);

                                                  if (
                                                      
                              $params->selectCity !== null
                                                      
                              && strlen($params->selectCity) < 100)
                                                  {
                                                      
                              // Ort aus Auswahl, Sicherheitsbegrenzer
                                                      
                              $sWhere = " WHERE Ort = '{$params->selectCity}'";
                                                  } elseif (
                              $aLine[$i]) {
                                                      
                              // aus Datensatz, Möglichkeit 1
                                                      
                              $sWhere = " WHERE id = $aLine[$i] ";
                                                  } else {
                                                      
                              // keine PLZ anzeigen bevor nicht Stadt ausgewählt
                                                      
                              $sLimit = 'LIMIT 1';
                                                  }

                                                  
                              $sQuery4 = "
                                                      SELECT id, Ort, PLZOrt
                                                      FROM PLZOrt
                                                      
                              $sWhere
                                                      ORDER BY PLZOrt"
                              ;
                                                  
                              $sth8 = $this->pdo->prepare($sQuery4);
                                                  
                              $sth8->execute();

                                                  
                              // Ausgewählte PLZ
                                                  
                              if ($this->isUpdate()) {
                                                      
                              // create und update
                                                      
                              $aZip[0][0] = $sth8->fetchAll(PDO::FETCH_ASSOC);
                                                  } else {
                                                      if (
                              $aLine[$i]) {
                                                          
                              // nur falls PLZOrt_id ausgefüllt, wird Ort
                                                          // angezeigt in Liste, read
                                                          
                              $aZip[$l] = $sth8->fetchAll(PDO::FETCH_ASSOC);
                                                      }
                                                  }
                                              } elseif (
                                                  
                              mysql_field_type($sql, $i) === 'int'
                                                  
                              && mysql_field_len($sql, $i) === 1
                                              
                              ) {
                                                  
                              // es gibt eine Checkbox
                                                  
                              $data->aCheckbox[$l][$i] = true;
                                              } elseif (
                              strpos(mysql_field_name($sql, $i), "_id") !== false) {
                                                  
                              // Verknüpfte Tabelle jeweilige Zeilen für Liste-Inhalt
                                                  // + ev. create/update

                                                  
                              $sTableName = explode('_id', mysql_field_name($sql, $i));

                                                  
                              $this->setIdStringByTableName($sTableName[0]);

                                                  
                              $sFirstColumn = $this->getFirstColumnByTableName(
                                                      
                              $sTableName[0]
                                                  );

                                                  
                              // Verschiedene Id-Spalten-Namen, deswegen $this->Id
                                                  
                              $sQuery9 = "
                                                      SELECT 
                              $this->sId, $sFirstColumn
                                                      FROM 
                              $sTableName[0]
                                                      WHERE 
                              $this->sId = $aLine[$i]";

                                                  
                              $Query = mysql_query($sQuery9);

                                                  while (
                              $aRow = mysql_fetch_row($Query)) {
                                                      
                              $data->Line[$l][$i] = $aRow[1];
                                                      
                              // id als Kontrolle
                              //                        $IdLinked[$l][$i] = $aRow[0];
                                                  
                              }

                                                  
                              // Liste zweidimensional
                                                  
                              $data->aTablesLinkedList[$l][$i] = $sTableName[0];

                              //                    $sth = $this->pdo->prepare($sQuery);
                              //                    $sth->execute();
                              //                    $aRow[] = $sth->fetchAll(PDO::FETCH_NUM);
                              //                    $Line[$l][$i] = $aRow[1];
                                              
                              }
                                          }

                                          
                              $l = $l + 1;
                                      }
                                  }

                                  
                              /**
                                   *
                                   */
                                  
                              public function getDataForPrintAction($table, $id)
                                  {
                                      
                              // Sicherheitsabfrage Tabellen
                                      
                              $sQuery = 'SHOW TABLES';
                                      
                              $aTables = HelpFunc::fetchPDO($sQuery, PDO::FETCH_COLUMN);

                                      if (
                              in_array($table, $aTables)) {
                                          
                              $sTable = $table;
                                      }

                                      
                              // Id prüfen
                                      
                              if (HelpFunc::is_id($id)) {
                                          
                              $nId =  $id;
                                      }

                                      
                              $sQuery2 = "
                                          SELECT artist, beschreibung_de
                                          FROM 
                              $sTable
                                          WHERE id = 
                              $nId";

                                      
                              $oStandard = $this->pdo->prepare($sQuery2);
                                      
                              $oStandard->execute();

                                      
                              // One Result, associativ array
                                      
                              $aMusician = $oStandard->fetch(PDO::FETCH_ASSOC);

                                      
                              // Name Musiker als assoziatives Array;
                                      
                              $sName = $aMusician['artist'] ;

                                      
                              $sContent = str_replace('<br>','', $aMusician['beschreibung_de']);
                                      
                              $sContent .= "\n Konzertagentur Dagmar Körner, Hepberg";

                                      return array(
                                          
                              'name'    => $sName,
                                          
                              'content' => $sContent
                                      
                              );
                                  }

                                  
                              /**
                                   *
                                   * @param ListDataParams $params
                                   * @return ListDataContainer
                                   */
                                  
                              public function getDataForListAction(ListDataParams $params)
                                  {
                                      
                              $data = new ListDataContainer();

                                      
                              $sth = $this->pdo->prepare($this->sQuery);
                                      
                              $sth->execute();
                                      
                              $data->nNumberFields = $sth->columnCount();
                                      
                              $data->aTablesMenu = $sth->fetchAll(
                                          
                              PDO::FETCH_ASSOC | PDO::FETCH_COLUMN
                                      
                              );

                                      
                              // im create/update-Bereich sollen alle Felder angezeigt werden
                                      
                              if ($data->nNumberFields > 11 && !$this->isUpdate()) {
                                          
                              $data->nNumberFields = 10;
                                      }

                                      
                              $sql = mysql_query($this->sQuery);

                                      
                              $this->doThingieOne($data, $sql);

                                      
                              $this->doThingieTwo($data, $sql, $params);

                                      
                              // Eher kosmetisch, aber der Inhalt muss ja nicht unnötig rumgeschleppt
                                      // werden
                                      
                              $this->listDataParams = null;

                                      return 
                              $data;
                                  }

                                  
                              /**
                                   *
                                   * @return array
                                   */
                                  
                              public function getDataForDownloadAction()
                                  {
                                      
                              $sDirectory = 'ImagesHighQuality/';

                                      
                              $handle = opendir($sDirectory);

                                      if (
                              $handle) {
                                          while (
                              false !== ($file = readdir($handle))) {
                                              if (
                              $file != "." && $file != "..") {
                                                  
                              $aFileName[] = $file;
                                              }
                                          }

                                          
                              closedir($handle);
                                      }

                                      
                              sort($aFileName);

                                      return array(
                                          
                              'FileType' => $sDirectory,
                                          
                              'aFile'    => $aFileName
                                      
                              );
                                  }
                              }
                              ListDataContainer.php:

                              PHP-Code:
                              <?php

                              /**
                               * 
                               */
                              class ListDataContainer
                              {
                                  public 
                              $aActions          = array();
                                  public 
                              $aCity             = array();
                                  public 
                              $bFieldZip         = false;
                                  public 
                              $aZip              = array();
                                  public 
                              $aWork             = array();
                                  public 
                              $aComposerSelected = array();
                                  public 
                              $aCheckbox         = array();
                                  public 
                              $aRowContent       = array();
                                  public 
                              $sFieldName        = array();
                                  public 
                              $Line              = array();
                                  public 
                              $aTablesLinked     = array();
                                  public 
                              $aTablesLinked2Dim = array();
                                  public 
                              $aTablesLinkedList = array();
                                  public 
                              $aTablesMenu       = array();
                                  public 
                              $aLinkedAll        = array();
                                  public 
                              $aLinkedAll2       = array();
                                  public 
                              $aFieldType        = array();
                                  public 
                              $aFieldHead        = array();
                                  public 
                              $FieldHead2Dim     = array();
                                  public 
                              $sFieldName        = '';
                                  public 
                              $nNumberFields     = 0;
                              }
                              ListDataParams:

                              PHP-Code:
                              <?php

                              /**
                               *
                               */
                              class ListDataParams
                              {
                                  
                              /**
                                   *
                                   * @var int
                                   */
                                  
                              public $selectComposer = null;

                                  
                              /**
                                   *
                                   * @var string
                                   */
                                  
                              public $selectCity = null;

                                  public function 
                              __construct($selectComposer, $selectCity)
                                  {
                                      
                              $this->selectComposer = $selectComposer;
                                      
                              $this->selectCity     = $selectCity;
                                  }
                              }
                              Die Idee ist es, die Instanziierung wesentlicher Abhängigkeiten so weit nach oben zu verlagern wie möglich.

                              Die Methodennamen doThingieOne, doThingieTwo und connectXy habe ich gewählt, weil ich es einerseits nicht besser beschreiben konnte und weil sie teilweise noch immer eine Ansammlung von random Sachen sind, die in weitere Methoden ausgelagert werden sollten.

                              Dass es ziemlich unschön ist, auf einmal mysql zu nutzen, obwohl PDO zur Verfügung steht, wurde glaube ich schon gesagt.

                              Kommentar

                              Lädt...
                              X