Question

I have heard several views on MVC structure in a web application. Some people believe the model should be very small, and only contain ActiveRecord (or some other ORM) and small things like validates and belongs_to, so model’s are only a couple lines long.

I personally think the model can play a larger role in apps. For example, I need to notify a user frequently throughout my app. The notifications can trigger from multiple controllers. They all send a notification to a user based on his or her notification settings, which is an object accessible through the user model.

I would like to make something like:

class User < ActiveRecord::Base
  #validations, relationships, etc

  def notify(event)
    notif = Notification.new
    notif.type = event.type
    notif.to = self.id
    # etc

    if notif.save
      # send the notification based on the settings
    end
  end
end

This would make it possible from any controller to use @user.notify to deliver messages to a user. This makes things really clean, but I realize there is some logic in my model. Not to mention the model makes another model.

Another approach I wouldn’t mind is creating the notification and sending it through that object. So controllers could do Notification.new(:to => @user.id, ...) and then deliver the message via a Notification.send. This would also put some logic in the Notification object so it knows how to send itself. In fact, I might like this approach better than creating the notification object through the User model.

I don’t mind these small bits of logic in the Model to make things convenient when sending messages from multiple controllers. Is this the best way to go about it? I suppose a more purist method is to include a NotificationHelper module in each controller that sends notifications?

edit: I’ve been reading a bit about “domain logic” in models. It seems like this is encouraged, and I suppose the notify or send methods are considered domain logic. Can any developer experienced in MVC comment on this?

Answer 1

For your second approach you can use ActiveRecord::Observer

 class NotificationObserver < ActiveRecord::Observer
   def after_create(notification)
       # some sending logic
   end
 end

But don’t be shy extract small pieces of logic into their own classes, like

lib/user_notify.rb

 class UserNotify
   def event_trigger(user,event)
       # some logic
   end
 end

use naming concepts suitable for your system (maybe Notify.send_user_about_event, etc.)