[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

// 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;
    }
}

[nikosch]

IMHO das Injecten eines spezialisierten View-Objektes pro Ansicht.

[ragtek]

Hm, was meinst du mit View Objekt?

Soweit ich mir das jetzt zamreime wäre es folgendes:
Pseudocode

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

[nikosch]

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.

[ragtek]

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

Aufruf im Moment:

$widget = new widget($shopdb);
$output = $widget->showNewest(10);
unset($widget); 

$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.

[nikosch]

Dann vielleicht in der Art:

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);