Unterschied zwischen Controller und Model in MVC

Ich denke, die is_logged sollte im Modell platziert für User. Beachten Sie, dass die User könnte ein Kunde in Ihrem Fall oder für jede Klasse, die Sie vorgenommen haben, zu Modell ein Benutzer des service.

Den valid_email und generate_random_string sind mehr oder weniger utility-Funktionen, die Sie können in einem Utility oder Utilities Modell, so dass diese wiederverwendbar, in verschiedenen Steuerungen in der Anwendung.

Den hash_password, montiert werden kann, entweder die User Modell oder Utility Modell. Ich bin mehr geneigt, um es in Utility Modell, da es ein Hash-Funktion, und es gibt nichts, was die user interessiert. Allerdings kann ich mir vorstellen, es kann sein argument(s) sonst.

Folgende Frage ALSO (obwohl für einen anderen Rahmen) kann auch als Faustregel:

Wohin mit den custom-Funktionen in Zend Framework 1.10

Controller kombinieren view mit dem Modell, so dass jede Validierung shoulde im Modell platziert werden
das ist mein Beispiel von kohana

CONTROLLER

<?php
/**
 * User Controller
 */
class Controller_Admin_User extends Controller_Admin_Template {

    public function action_index()
    {
        $this->template->body = View::factory('admin/user/index')
                ->set('i', 0)
                ->bind('users', $users)
                ->bind('groups', $groups)
                ->bind('id_user_group', $id_user_group);

        $model_user = new Model_Admin_User;
        $users = $model_user->get_users(Arr::get($_GET, 'sort'), Arr::get($_GET, 'order'));

        $model_usergroup = new Model_Admin_Usergroup;
        $groups = $model_usergroup->get_user_group();
    }

    public function action_add()
    {
        $this->template->body = View::factory('admin/user/form_add')
                ->bind('error', $error)
                ->bind('groups', $groups)
                ->bind('post', $post);

        $model_usergroup = new Model_Admin_Usergroup;
        $groups = $model_usergroup->get_user_group();

        if($_POST)
        {
            $model_user = new Model_Admin_User;
            if($model_user->save($_POST) == false)
            {
                $error = $model_user->error;
                $post = $_POST;
            }
            else
            {
                $this->request->redirect('admin/user');
            }
        }
    }

MODELL

class Model_Back_User extends Model {

    private $qb;

    public $aliases = array(
        'id'=> 'id_user'
    );

    public $error = array(
        'name'          => null,
        'surname'       => null,
        'login'         => null,
        'password'      => null,
        'id_user_group' => null,
        'old_password'  => null,
        'new_password'  => null,
        'confirm'       => null,
        'email'         => null,
        'phone'         => null,
    );

    private $rules = array(
        'name'          => array('not_empty' => null, 'alpha' => null),
        'surname'       => array('not_empty' => null, 'alpha' => null),
        'login'         => array('not_empty' => null),
        'password'      => array('not_empty' => null),
        'id_user_group' => array('not_empty' => null),
        'email'         => array('not_empty' => null, 'email' => null),
        'phone'         => array('not_empty' => null),
        'old_password'  => array('not_empty' => null),
        'new_password'  => array('not_empty' => null),
        'confirm'       => array('matches'   => array('new_password'))
    );

    public function __construct()
    {
        $this->qb = new Querybuilder;
        //parent::__construct();
    }

    public function change_password($data)
    {       
        $validate = Validate::factory($data)
            ->filter(true,              'trim')
            ->rules('old_password',     $this->rules['old_password'])
            ->rules('new_password',     $this->rules['new_password'])
            ->rules('confirm',          $this->rules['confirm'])
            ->callback('old_password',  array($this, 'password_exists'), array('id_user'=> $data['id_user']));

        if($validate->check() == false)
        {
            $this->error = array_merge($this->error, $validate->errors('user'));
            return false;
        }

        $u = Session::instance()->get('user');
        $this->edit(array('password'=> $this->password($data['new_password'])), array('id_user'=> $u['id_user']));
        return true;
    }

    public function password_exists(Validate $valid, $field, $param)
    {
        if($this->user_exists(array('password'=> $this->password($valid[$field]), 'id_user'=> $param['id_user'])) == false)
        {
            $valid->error($field, 'old password is incorrect', array($valid[$field]));
        }
    }

    public function save($data)
    {
        $validate = Validate::factory($data)
            ->filter(true, 'trim')
            ->rules('name', $this->rules['name'])
            ->rules('surname', $this->rules['surname'])
            ->rules('user_group_id', $this->rules['id_user_group'])
            ->rules('email', $this->rules['email'])
            ->rules('phone', $this->rules['phone']);

        $edit = false;
        if(isset($data['id_user']) AND Validate::not_empty($data['id_user']))
        {
            $edit = true;
        }
        else
        {
            $validate->rules('login', $this->rules['login'])
                    ->rules('password', $this->rules['password']);
        }

        if($validate->check() == false)
        {
            $this->error = array_merge($this->error, $validate->errors('user'));
            return false;
        }

        if($edit == true)
        {
            $this->edit(
                array(
                    'name'          => $data['name'],
                    'user_group_id' => $data['user_group_id']
                ),
                array(
                    'id_user'=> $data['id_user']
                )
            );
            return true;
        }
        return $this->add(
                    array(
                        'name'          => $data['name'],
                        'login'         => $data['login'],
                        'password'      => $data['password'],
                        'user_group_id' => $data['user_group_id']
                    )
                );
    }

    protected function add($data)
    {        
        $data['password'] = $this->password($data['password']);

        return $this->_db->query(Database::INSERT, 
            $this->qb->insert('user')->set($data)->build_query()
        );
    }

Sicht nicht so wichtig ist, warum ich nicht das hier.

Habe ich mit Codeigniter für eine lange Zeit und ich das machen würde, die folgenden mit Ihren Funktionen so weit wie die Platzierung geht:

hash_password              //returns hash password. 

Ich würde etwas wie einen Passwort hasher, in einer Bibliothek oder Helfer-Datei, so konnte ich rufen es von meinem controller, wie:

//pretend library I'd make for tasks like hashing etc
$this->load->library('passwords');
//transform posted password into it's hashed version   
$password = $this->password_library->hash_password($this->input->post('password'));

Ich nehme an, Sie wollen die hash/salt, Passwort und speichern Sie in Ihrer Datenbank in diesem Beispiel

valid_email               //validates email format and return true or false

Dies ist bereits in form_validation, so...

is_logged                //check if session has a variable, returns true or false

Diese sollte auch eine Verbindung mit einem Authentifizierungs-Bibliothek

generate_random_string  //generates and hashes a random string

Wieder, dieser würde kommen, aus einer Bibliothek oder Helfer.

SO, WENN TUN SIE VERWENDEN EIN MODELL???

Mich, ich Modelle, die ausschließlich für in/out auf der Datenbank. Alle meine Fragen dort zu gehen. Normalerweise habe ich mein Modell, die Funktionen zurückgeben von Daten-Objekten, so kann ich eine Schleife in meinen Ansichten.

Controller rufen Sie die Daten aus Ihrer Modelle, dann werfen Sie alles in Ihren Ansichten. Außerhalb Funktionalität geht immer in Bibliotheken und Helfer. Ich mag die "MY_library" und erweitern Codeigniter eigenen Zeug - vor allem mit den Formen und der html-helper usw.