Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] Eine "Ausgabeklasse" so flexibel wie möglich machen

Einklappen

Neue Werbung 2019

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

  • [Erledigt] Eine "Ausgabeklasse" so flexibel wie möglich machen

    Ich habe eine Klasse erstellt, die mir Artikel aus einem Shop anzeigt.
    Mein Problem ist nun, dass diese ziemlich unflexibel ist.
    Im Moment hat diese nur 2 "Verwendungsmöglichkeiten" =>neueste & spezial Artikel anzeigen

    Meine 1. Überlegung war, dass ich es für den Benutzer so einfach wie möglich mache und dieser einfach eine der 2 show Methoden aufzurufen braucht.

    Mit der Zeit werden hier aber noch xxx neue Ausgaben dazukommen.

    Jetzt ist es doch Schwachsinn das ich für jede neue MÖglichkeit 2 neue Methoden (showXXX und fetchQueryXXX) erstelle und den Switch Teil in der fetchItems Methode anpassen.

    Was wäre hier nun die eleganteste Möglichkeit?

    PHP-Code:

    <?php

    // change 27.3 : vb registry entfernt
    // da die klasse soweit ich das merke keine vb Registry benögtigt, wurde sie ausgebaut
    //

    namespace ragtek\vbullet\oscommerce;

    class 
    widget
    {
        
    // oscommerce db connection
        
    private $osdb;
        
    // saves if we want to show newest or special articles
        
    private $called;

        private 
    $queryresult;
        

        public function  
    __construct(vB_Database $osdb null)
        {
                
    $this->osdb $osdb;
        }

        public function 
    showNewest($counter 5$show true)
        {
            
    $this->fetchItems('new'$counter);
            if (
    $show == true)
            {
                return 
    $this->generateOutput();
            }
            else
            {
                return 
    $this->queryresult;
            }
        }

        
    /**
         * return the special x items or the parsed template with them
         * @param <int> how many items should be fetched
         * @param <bool> parse the template? 
         * @return <mixed >
         */
        
    public function showSpecial($counter 5$show true)
        {
            
    $this->fetchItems('special'$counter);
            if (
    $show == true)
            {
                return 
    $this->generateOutput();
            }
            else
            {
                return 
    $this->queryresult;
            }
        }

        
    /**
         *
         * @param <int> $counter
         * @return <string> query
         */
        
    private function fetchNewestQuery($counter)
        {
            
    $query "xx";
            return 
    $query;
        }

        
    /**
         *
         * @param <int> $counter
         * @return <string> query
         */
        
    private function fetchSpecialQuery($counter)
        {
            
    $query "xx";
            return 
    $query;
        }


        
    /**
         * fetch items from the database and save them into $this->queryresult
         * @param <type> what should be fetched ? special, new
         * @param <type> how many items should be fetched?
         * @return <array> $this->queryresult
         */
        
    protected function fetchItems($what$counter){
            
    $this->called $what;

            switch (
    $what) {
                case 
    'special':
                    
    $query $this->fetchSpecialQuery($counter);
                    break;
                case 
    'new':
                    
    $query $this->fetchNewestQuery($counter);
                    break;
                default:
                    throw new 
    Exception('Keine gültige Aktion ausgewählt'); // über phrase lösen
                    #throw new Exception($vbphrase['no_valid_action']);
            
    }
            
    $articles $this->odb->query($query);
            while (
    $article $this->odb->fetch_array($articles) )
            {
                        
    $this->queryresult["$article[products_id]"] = $article[];
            }
            
    $this->odb->free_result();
            return 
    $this->queryresult;
        }

        private function 
    generateOutput()
        {
            if (
    count($this->queryresult) == 0)
            {
                
    // todo hier auch noch etwas einfallen lassen für die ausgabe. eventuell phrase
                
    return '0';
            }
            
    $output '';
            foreach (
    $this->queryresult as $article) {
                   
    $article['price'] = number_format($article['products_price'], 2);
                   if (
    $this->called == 'special')
                   {
                      
    $article['new_price'] = number_format($article['specials_new_products_price'], 2);
                   }
                   
    $templater vB_Template::create('oscommerce_product');
                        
    $templater->register('article'$article);
                        
    $templater->register('g'$templateglobals);
                   
    $output .= $templater->render();
            }
            return 
    $output;
        }
    }


  • #2
    IMHO das Injecten eines spezialisierten View-Objektes pro Ansicht.
    --

    „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
    Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


    --

    Kommentar


    • #3
      Hm, was meinst du mit View Objekt?

      Soweit ich mir das jetzt zamreime wäre es folgendes:
      Pseudocode
      PHP-Code:
      class specialArticle {
      function 
      query { return 'xxx'; }
      ..
      }
      class 
      newArticle {
      function 
      query { return 'xx'; }
      }

      $articles = new specialArticle();
      $widget = new widget($articles); 
      Meinst du so etwas?

      MIr ist noch etwas gerade eingefallen.
      1. Abstrakte Artikelklasse
      2. die einzelnen Ausgaben erben von der Artikelklasse und erweitern diese nur um den query und eine Konstante damit man für die Ausgabe weiß, was jetzt verwenden wird

      Kommentar


      • #4
        Bitte mach das nicht! Es fängt schon damit an, dass die Query vielleicht mal verschiedene Parameter als Eingabe benötigt. Schon bekommst Du Probleme, weil Deine Methoden unterschiedliche Schnittstellen bekommen.

        Beschreib doch mal, wie das für den Endnutzer später aussehen soll.
        --

        „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
        Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


        --

        Kommentar


        • #5
          Naja der Endbenutzer hat im Moment ein "Feld" (Textarea) wo er den Code manuell einfügen muss.

          Aufruf im Moment:
          PHP-Code:
          $widget = new widget($shopdb);
          $output $widget->showNewest(10);
          unset(
          $widget); 
          PHP-Code:
          $widget = new widget($shopdb);
          $output $widget->showSpecial();
          unset(
          $widget); 
          usw


          Später soll das dann über eine schöne Oberfläche gehandhabt werden.
          Damit man sichs vorstellen kann, so in etwa:
          Das heißt, die Werte aus dem Formular werden in einem Config Array gespeichert und dazu habe ich mir überlegt eine Factory Klasse zu erstellen, die den Rest dann handhabt.
          Das heißt, in einem späteren Refactoring Vorgang werden die einzelnen Methoden showXX sowieso unnötig, da der Klassenaufruf dann automatisch geschiet und kein Code manuell irgendwo eingegeben werden muss.

          Momentan brauche ich die einzelnen Methoden aber als Wrapper.
          Hoffe man versteht was ich meine.

          Kommentar


          • #6
            Dann vielleicht in der Art:

            PHP-Code:

            interface WidgetDAO 
              
            {
              function 
            fetchQuery (...);
              }

            class 
            widgetDAO_showNewest implements WidgetDAO 
              
            {
              ...
              }

            class 
            widget 
              
            {
              function 
            __construct (WidgetDAO $dao)
                {
                
            $this->view = new widgetView ($dao);
                }

              function 
            getView ()
                {
                return (
            $this->view);
                }
              }

            switch (...) {
              case ...:
                
            $type 'showNewest';
                
            $settings = array ('size' => 10 , ...);
                break;
              ...
            }

            $dao DAOFactory::create ($type $settings $shopdb);

            $widget = new widget($dao);
            $view   $widget->getView();
            $view->render();

            unset(
            $widget); 
            --

            „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
            Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


            --

            Kommentar

            Lädt...
            X