Aufteilung der Funktion, MVC

[vapita]

Hallo Rolf,

register

Was befindet sich, wenn Du $this->user->validate aufrufst, im user Property des UserControllers?

Das ist die User-Klasse mit den Validierungen.

Ich habe $this->user = new User(); im Abstrakten Controller verwendet von dem Jeder Controller erbt. Jedoch erscheint mir das inzwischen nicht mehr sinnvoll, da ich ja die User-Validierung gar nicht in jedem Controller benötige.

try {
   ...
   $user = new User($userData);
   $user->validate($userRepository);
   $this->getEntityManager()->persist($user);
   $this->flash->add(200);
   $this->redirect('302', 'user/login');
}
catch (Exception $validationException) {
   this->flash->add($validationException->getMessage(), 'danger');
}

Das ist ein guter Tipp. Danke dafür.

Über Entitymanager und Repository wollte ich gerade auch schon anfangen, aber aber klugerweise mal gegoogelt. Du verwendest Symfony und Doctrine - das ist also so vorgegeben für Dich. Jetzt verstehe ich auch, warum Du fleißig set-Methoden verwendest. Das muss so, sonst bekommt Doctrine nicht mit, dass sich Propertywerte ändern.

Das sieht tatsächlich so aus. Ist es aber gar nicht. Hinter der EntityManager Klasse befindet sich noch ein unaufgeräumtes Kinderzimmer. Ich habe mich allerdings von Doctrine inspirieren lassen. Allerdings nutze ich die Twig Engine für die View.

# EntityManager.php
use \ReflectionClass;
use \ReflectionProperty;
use \ReflectionException;
use \Exception;
use Btinet\Ringhorn\Logger;

class EntityManager
{
    protected $db;
    protected $entity;

    function __construct()
    {
       $this->db = new Database();
    }

    public function persist($entity, $id = false){
        self::generateReflectionClass($entity);
        $class_name = strtolower($this->entity->getShortName());
        foreach($this->entity->getProperties() as $property){
            foreach ($property as $key => $value){
                if($key == 'name'){
                    $rp = new ReflectionProperty($entity, $value);
                    if($rp->isInitialized($entity)){
                        $mvalue = ucfirst($value);
                        $method = "get$mvalue";

                        $data[$value] = $entity->$method();
                    }
                }
            }
        };
        if ($id){
            $row = $this->db->select("SELECT * FROM $class_name WHERE id = :id", ['id' => $id]);
            if ($row){
                return $this->db->update($class_name, $data, ['id' => $id]);
            }
        } else {
            return $this->db->insert($class_name, $data);
        }
    }

    public function remove($entity, $id)
    {
        self::generateReflectionClass($entity);
        $class_name = strtolower($this->entity->getShortName());
        if ($id) {
            $row = $this->db->select("SELECT * FROM $class_name WHERE id = :id", ['id' => $id]);
            if ($row) {
                return $this->db->delete($class_name, ['id' => $id]);
            }
        } else {
            return false;
        }
    }

    public function truncate($entity)
    {
        self::generateReflectionClass($entity);
        $class_name = strtolower($this->entity->getShortName());
        try {
            return $this->db->truncate($class_name);
        } catch (Exception $e){
            Logger::newMessage($e);
            Logger::customErrorMsg($e);
        }
    }

    protected function generateReflectionClass($entity){
        try {
            return $this->entity = new ReflectionClass($entity);
        } catch (ReflectionException $reflectionException){
            Logger::newMessage($reflectionException);
            Logger::customErrorMsg($reflectionException);
        }
    }

}

Der Manager setzt im Prinzip für jede initialisierte Property der Entity-Klassen die Werte für die SQL-Abfragen. Daher die ganzen set-Methoden.

Beste Grüße

vapita