Kohana Forums

I have been calling a model in the controller and passing it into the view as an object. The view class then builds its datasets using the model that I gave it. It also means that the controller has access to the model to do anything else you want.

Here's a sample controller action:


public function action_new()
{
$view = new View_Admin_Post_New;
$view->post_obj = $post = new Model_Post;

if ($_POST)
{
$post->values(arr::extract($_POST, array('title', 'text')));
$post->user_id = Auth::instance()->get_user()->id;
$post->generate_slug();

if ($post->check())
{
$post->save();
$this->request->redirect('admin/posts');
}
}

$this->request->response = $view;
}


And here's a sample from the view class that goes with it.


public $post_obj;

public function errors()
{
return $this->post_obj->validate()->errors();
}

public function post_title()
{
return $this->post_obj->title;
}


You could always cache it.

@xenakis: I'm not sure if I misunderstood your example - View_Category_Menu and View_Category_Breadcrumb are partials that are both loaded together (ie part of the same page)? If so, couldn't you query the Category model in the calling view class, and pass to each of the partials view classes?

@LordZicon - On the site I am making View_Category_Menu always appears. However, View_Category_Breadcrumb is not on every page. For example, if you are browsing user pages, you don't see the Category_Breadcrumb. You only see them both when browsing categories.

In Kostache, although you can locally instantiate a Model from the view, the better practice is to let the Controller create/instantiate the Model and make it available as a global instance which can be reused by the Controller and the View and even by controllers through HMVC. To make this possible, I created a static Model class with 2 methods, `Model::factory()` and `Model::instance()`. Using Model::factory() will always return a newly instantiated model, Model::instance() will instantiate a model if it doesn't exist yet, but it will return the same model if it was already instantiated.

The parameters I pass to those methods are simple string "keys" or "routes" which maps to the correct model. So I use it like this `Model::instance('modeldir/modelfile', [namespace]);`. So what happens here is that if I want to use Model_Category everywhere, it will look like this: `Model::instance('model/category')->get_list();`. If I want to prepare the Model for display by the View, the controller can just set its state.

In my Controller, I set the model state like this:


public function action_foo(){
// This instantiates the Model
Model::instance('model/foo')
->set_state('limit', 5)
->set_state('ordering', 'DESC');
}


Then in my Kostache view:


class Views_Foo extends Kostache{
public function categories(){
// This does not instantiate the model, but gets the instance created by the controller.
return Model::instance('model/foo')->get_list();
}
}


Just remember that the Controller is not the data police http://bit.ly/bACEr2 so any filtering or manipulation of data should not be done by the controller. The Controller just set the Model's states then the Model will react based on the states. The View should just get the data that's ready to be displayed.

Hope this helps.

IMHO you should define the state of the data where you wish to use it i.e. in the view itself.

Partials are great.

@zombor is there any decent way in adding partials to $_partials to the inherited partials from a parent view?

@DrPheltRight: In the constructor of your child view, couldn't you do something like this:

$this->_partials += array('name'=>'path');

Thanks for your help guys. I'll try to come up with something today. I agree that the model should be called from the view, just figuring out how to avoid repeated queries. I think you gave me some good ideas. Just have to work this all out.

It would really help if there were more detailed examples of this. Seeing code in action is always the best help.

> It would really help if there were more detailed examples of this. Seeing code in action is always the best help.

Vendo uses mustache to it's full potential: http://github.com/zombor/Vendo

@raeldc - Iv'e been thinking things through and I like your suggestion. Indeed, I need my model to stay alive so I can use it elsewhere. The problem is I'm baffled on how you "created a static Model class with 2 methods". Do you extend the model class for this?

It's the controller's job to tell the view what the filters are, it is not the controller's job to decide what to display. You're just making your application incredibly difficult to understand.

@raeldc - Thanks for the code, it's very much appreciated. I'll try to work out something with it today.

@xenakis just improve the code. For one, you may auto-append "model" in the model path so you just call it like this Model::instance('test')->hello();