How skinny should controllers, and how fat should models be?

Exactly how skinny should a controller be? I understand putting all of the business logic inside the models, but what about other things.

For example, say I was writing a blog site where each user can have multiple posts. Currently, the user would create posts by visiting the posts controller and running the create action. Here is a little sample of what would happen currently.

class Controller_Post extends Controller {
  function action_create() {
    if ( ! empty($_POST)) {
        $post = new Model_Post;
        $post->user_id = $this->logged_in_user->id;
        $post->values($_POST);
        if ( ! $post->create()) {
            echo 'Error';
        }
        else
        {
            echo 'Saved';
        }
    }
  }
}

My question is, what would stop me from putting the above logic in the user model, like so.

class Model_User extends Model {
function create_post($post) {
            $post = Model::factory('post')->values($post);
    $post->user_id = $this->id;
    if ( ! $post->create()) {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}
}

If it were done this way, the controller would be even smaller than what I put. It makes more sense to me because the user is the one creating the post, so I think it should be in the user model as opposed to the controller.

If it helps, Im using the Kohana framework.开发者_高级运维

Thanks

Controllers should be directing traffic. Models are for where your business logic goes, so in general your second example would be "correct mvc".

Basically what a controller should be doing is requesting input, telling models to change state (they do the actual state change themselves), and determining which view to display (if any).

I have many controllers which simply are like so:

class Controller_Foobar extends Controller
{
    public function action_index() {}
}

And if they need to process $_POST input, they grab that data, and send it off to the model, then the view.

Keeping all that logic inside your models lets you easily reuse it, and it's more maintainable and testable.