social_stream 0.9.1 → 0.9.2

data/base/app/mailers/invitation_mailer.rb

@@ -0,0 +1,11 @@
+class InvitationMailer < ActionMailer::Base
+  
+  default :from => Mailboxer.default_from
+  
+  def send_invitation(receiver, sender, message)
+    @sender= sender
+    @message= message  
+    mail(:to => receiver, :subject => "SocialStream Invitation")
+  end
+
+end

data/base/app/mailers/notification_mailer.rb

@@ -0,0 +1,34 @@
+#OVERRING WARNING
+#We must override the NotificationMailer from Mailboxer to change the new_notification_email method
+#refer to it for more info
+#NOTE: There is just few lines different from original Mailboxer NotificationMailer. Please maintain it
+#updated for correct behaviour
+class NotificationMailer < ActionMailer::Base
+  default :from => Mailboxer.default_from
+  #Sends and email for indicating a new notification to a receiver.
+  #It calls new_notification_email.
+  def send_email(notification,receiver)
+    new_notification_email(notification,receiver)
+  end
+
+  include ActionView::Helpers::SanitizeHelper
+  #DIFFERENT FROM ORIGINAL----------------------
+  include Mailboxer::NotificationDecoder
+  #END OF DIFFERENCE----------------------------
+
+  #Sends an email for indicating a new message for the receiver
+  def new_notification_email(notification,receiver)
+    @notification = notification
+    @receiver = receiver
+    #DIFFERENT FROM ORIGINAL----------------------
+    subject = notification.subject.to_s
+    subject = decode_basic_notification(subject,notification.notified_object)
+    subject = subject.gsub(/\n/,'')
+    #END OF DIFFERENCE----------------------------
+    subject = strip_tags(subject) unless subject.html_safe?
+    mail(:to => receiver.send(Mailboxer.email_method,notification), :subject => t('mailboxer.notification_mailer.subject', :subject => subject)) do |format|
+      format.text {render __method__}
+      format.html {render __method__}
+    end
+  end
+end

data/base/app/models/ability.rb

@@ -0,0 +1,2 @@
+class Ability < SocialStream::Ability
+end

data/base/app/models/activity.rb

@@ -0,0 +1,321 @@
+# Activities follow the {Activity Streams}[http://activitystrea.ms/] standard.
+#
+# == Activities, Contacts and Audiences
+# Every activity is attached to a {Contact}, which defines the sender and the receiver of the {Activity}
+#
+# Besides, the activity is attached to one or more relations, which define the audicence of the activity,
+# the {actors Actor} that can reach it and their {permissions Permission}
+#
+# == Wall
+# The Activity.wall(args) scope provides all the activities appearing in a wall
+#
+# There are two types of wall, :home and :profile. Check {Actor#wall} for more information
+#
+class Activity < ActiveRecord::Base
+  has_ancestry
+
+  paginates_per 10
+
+  belongs_to :activity_verb
+
+  belongs_to :contact
+  has_one :sender,   :through => :contact
+  has_one :receiver, :through => :contact
+
+  has_many :audiences, :dependent => :destroy
+  has_many :relations, :through => :audiences
+
+  has_many :activity_object_activities,
+           :dependent => :destroy
+  has_many :activity_objects,
+           :through => :activity_object_activities
+
+  scope :wall, lambda { |args|
+    q =
+      select("DISTINCT activities.*").
+      joins(:contact).
+      joins(:audiences).
+      joins(:relations).
+      roots
+
+    if args[:object_type].present?
+      q = q.joins(:activity_objects).
+            where('activity_objects.object_type' => args[:object_type])
+    end
+
+    contacts   = Contact.arel_table
+    audiences  = Audience.arel_table
+    relations  = Relation.arel_table
+
+    owner_conditions =
+      contacts[:sender_id].eq(Actor.normalize_id(args[:owner])).
+        or(contacts[:receiver_id].eq(Actor.normalize_id(args[:owner])))
+
+    audience_conditions =
+      audiences[:relation_id].eq(args[:relations]).
+        or(relations[:type].eq('Relation::Public'))
+
+    conds =
+      case args[:type]
+      when :home
+        followed_conditions =
+          contacts[:sender_id].in(args[:followed]).
+            or(contacts[:receiver_id].in(args[:followed]))
+
+        owner_conditions.
+          or(followed_conditions.and(audience_conditions))
+      when :profile
+        if args[:for].present?
+          visitor_conditions =
+            contacts[:sender_id].eq(Actor.normalize_id(args[:for])).
+              or(contacts[:receiver_id].eq(Actor.normalize_id(args[:for])))
+
+          owner_conditions.
+            and(visitor_conditions.or(audience_conditions))
+        else
+          owner_conditions.
+            and(audience_conditions)
+        end
+      else
+        raise "Unknown wall type: #{ args[:type] }" 
+      end
+
+    q.where(conds).
+      order("created_at desc")
+  }
+
+  before_validation :fill_relations
+
+  after_create  :increment_like_count
+  after_destroy :decrement_like_count, :delete_notifications
+
+  validates_presence_of :relations
+ 
+  #For now, it should be the last one
+  #FIXME
+  after_create :send_notifications
+
+  # The name of the verb of this activity
+  def verb
+    activity_verb.name
+  end
+
+  # Set the name of the verb of this activity
+  def verb=(name)
+    self.activity_verb = ActivityVerb[name]
+  end
+
+  # The {Actor} author of this activity
+  #
+  # This method provides the {Actor}. Use {#sender_subject} for the {SocialStream::Models::Subject Subject}
+  # ({User}, {Group}, etc..)
+  def sender
+    contact.sender
+  end
+
+  # The {SocialStream::Models::Subject Subject} author of this activity
+  #
+  # This method provides the {SocialStream::Models::Subject Subject} ({User}, {Group}, etc...).
+  # Use {#sender} for the {Actor}.
+  def sender_subject
+    contact.sender_subject
+  end
+
+  # The wall where the activity is shown belongs to receiver
+  #
+  # This method provides the {Actor}. Use {#receiver_subject} for the {SocialStream::Models::Subject Subject}
+  # ({User}, {Group}, etc..)
+  def receiver
+    contact.receiver
+  end
+
+  # The wall where the activity is shown belongs to the receiver
+  #
+  # This method provides the {SocialStream::Models::Subject Subject} ({User}, {Group}, etc...).
+  # Use {#receiver} for the {Actor}.
+  def receiver_subject
+    contact.receiver_subject
+  end
+
+  # The comments about this activity
+  def comments
+    children.includes(:activity_objects).where('activity_objects.object_type' => "Comment")
+  end
+
+  # The 'like' qualifications emmited to this activities
+  def likes
+    children.joins(:activity_verb).where('activity_verbs.name' => "like")
+  end
+
+  def liked_by(user) #:nodoc:
+    likes.joins(:contact).merge(Contact.sent_by(user))
+  end
+
+  # Does user like this activity?
+  def liked_by?(user)
+    liked_by(user).present?
+  end
+
+  # Build a new children activity where subject like this
+  def new_like(subject)
+    a = children.new :verb => "like",
+                     :contact => subject.contact_to!(receiver),
+                     :relation_ids => self.relation_ids
+
+    if direct_activity_object.present?
+      a.activity_objects << direct_activity_object
+    end
+
+    a
+  end
+
+  # The first activity object of this activity
+  def direct_activity_object
+    activity_objects.first
+  end
+
+  # The first object of this activity
+  def direct_object
+    direct_activity_object.try(:object)
+  end
+
+  # The title for this activity in the stream
+  def title view
+    case verb
+    when "follow", "make-friend", "like"
+      I18n.t "activity.verb.#{ verb }.#{ receiver.subject_type }.title",
+      :subject => view.link_name(sender_subject),
+      :contact => view.link_name(receiver_subject)
+    when "post"
+      if sender == receiver
+        view.link_name sender_subject
+      else
+        I18n.t "activity.verb.post.title.other_wall",
+               :sender => view.link_name(sender_subject),
+               :receiver => view.link_name(receiver_subject)
+      end
+    end.html_safe
+  end
+
+  def notificable?
+    is_root? or ['post','update'].include?(root.verb)
+  end
+
+  def notify
+    return true if !notificable?
+    #Avaible verbs: follow, like, make-friend, post, update
+    actionview = ActivitiesController.new.view_context
+
+    if ['like','follow','make-friend','post','update'].include? verb and !contact.reflexive?
+      notification_subject = actionview.render :partial => 'notifications/activities/' + verb + "_subject", :locals => {:activity => self}
+      notification_body = actionview.render :partial =>  'notifications/activities/' + verb + "_body", :locals => {:activity => self}
+      receiver.notify(notification_subject, notification_body, self)
+    end
+    true
+  end
+
+  # Is subject allowed to perform action on this {Activity}?
+  def allow?(subject, action)
+    return false if contact.blank?
+
+    case action
+    when 'create'
+      return false if contact.sender_id != Actor.normalize_id(subject)
+
+      rels = Relation.normalize(relation_ids)
+
+      own_rels     = rels.select{ |r| r.actor_id == contact.sender_id }
+      foreign_rels = rels - own_rels
+
+      # Only posting to own relations or allowed to post to foreign relations
+      return foreign_rels.blank? && own_rels.present? ||
+             foreign_rels.present? && Relation.allow(subject, 
+                                                     action,
+                                                     'activity',
+                                                     :in => foreign_rels).
+                                               all.size == foreign_rels.size
+
+    when 'read'
+      return true if relations.select{ |r| r.is_a?(Relation::Public) }.any?
+
+      return false if subject.blank?
+
+      return true if [contact.sender_id, contact.receiver_id].include?(Actor.normalize_id(subject))
+    when 'update'
+      return true if contact.sender_id == Actor.normalize_id(subject)
+    when 'destroy'
+      # We only allow destroying to sender and receiver by now
+      return [contact.sender_id, contact.receiver_id].include?(Actor.normalize_id(subject))
+    end
+
+    Relation.
+      allow?(subject, action, 'activity', :in => self.relation_ids, :public => false)
+  end
+
+  # Can subject delete the object of this activity?
+  def delete_object_by?(subject)
+    subject.present? &&
+    direct_object.present? &&
+      ! direct_object.is_a?(Actor) &&
+      ! direct_object.class.ancestors.include?(SocialStream::Models::Subject) &&
+      allow?(subject, 'destroy')
+  end
+
+  # The {Relation} with which activity is shared
+  def audience_in_words(subject)
+    visible_relations =
+      relations.select{ |r| r.actor_id == Actor.normalize_id(subject) || r.is_a?(Relation::Public) }
+
+    visible_relations.present? ?
+      I18n.t('activity.audience.visible', :audience => visible_relations.map(&:name).join(", ")) :
+      I18n.t('activity.audience.hidden', :audience => relations.map(&:actor).map(&:name).join(", "))
+  end
+
+  private
+
+  # Before validation callback
+  #
+  # Fill the relations when posting to other subject's wall
+  def fill_relations
+    return if relation_ids.present?
+
+    self.relation_ids =
+      if contact.reflexive?
+        Array(receiver.relation_public.id)
+      else
+        receiver.relation_customs.allow(contact.sender, 'create', 'activity').map(&:id)
+      end
+  end
+
+  #Send notifications to actors based on proximity, interest and permissions
+  def send_notifications
+    notify
+  end
+
+  # after_create callback
+  #
+  # Increment like counter in objects with a like activity
+  def increment_like_count
+    return if verb != "like" || direct_activity_object.blank?
+
+    direct_activity_object.increment!(:like_count)
+  end
+
+  # after_destroy callback
+  #
+  # Decrement like counter in objects when like activity is destroyed
+  def decrement_like_count
+    return if verb != "like" || direct_activity_object.blank?
+
+    direct_activity_object.decrement!(:like_count)
+  end
+  
+  # after_destroy callback
+  #
+  # Destroy any Notification linked with the activity
+  def delete_notifications
+    Notification.with_object(self).each do |notification|
+      notification.destroy
+    end
+  end
+end

data/base/app/models/activity_object.rb

@@ -0,0 +1,31 @@
+# The {ActivityObject} is any object that receives actions. Examples are
+# creating post, liking a comment, contacting a user. 
+#
+# = ActivityObject subtypes
+# All post, comment and user are {SocialStream::Models::Object objects}.
+# Social Stream privides 3 {ActivityObject} subtypes, {Post}, {Comment} and
+# {Actor}. The application developer can define as many {ActivityObject} subtypes
+# as required.
+# Objects are added to +config/initializers/social_stream.rb+
+#
+class ActivityObject < ActiveRecord::Base
+  @subtypes_name = :object
+  include SocialStream::Models::Supertype
+
+  acts_as_taggable
+  
+  has_many :activity_object_activities, :dependent => :destroy
+  has_many :activities, :through => :activity_object_activities
+
+  # The object of this activity object
+  def object
+    subtype_instance.is_a?(Actor) ?
+      subtype_instance.subject :
+      subtype_instance
+  end
+
+  # The activity in which this activity_object was created
+  def post_activity
+    activities.includes(:activity_verb).where('activity_verbs.name' => 'post').first
+  end
+end

data/base/app/models/activity_object_activity.rb

@@ -0,0 +1,14 @@
+class ActivityObjectActivity < ActiveRecord::Base
+  belongs_to :activity, :dependent => :destroy
+  belongs_to :activity_object
+
+  before_create :default_object_type
+
+  private
+  
+  # Default objects are direct objects. http://activitystrea.ms/head/atom-activity.html#activity.object
+  # Other type of objects are targets.  http://activitystrea.ms/head/atom-activity.html#activity.target
+  def default_object_type
+    self.object_type ||= "object"
+  end
+end

data/base/app/models/activity_verb.rb

@@ -0,0 +1,22 @@
+class ActivityVerb < ActiveRecord::Base
+  # Activity Strems verbs
+  Available = %w(follow like make-friend post update)
+
+  validates_uniqueness_of :name
+
+  has_many :activities
+
+  scope :verb_name, lambda{ |n|
+    where(:name => n)
+  }
+
+  class << self
+    def [] name
+      if Available.include?(name)
+        find_or_create_by_name name
+      else
+        raise "ActivityVerb not available: #{ name }"
+      end
+    end
+  end
+end

data/base/app/models/actor.rb

@@ -0,0 +1,491 @@
+# An {Actor} is a social entity. This includes individuals, but also groups, departments,
+# organizations even nations or states.
+#
+# Actors are the nodes of a social network. Two actors are linked by a {Tie}. The
+# type of a {tie} is a {Relation}. Each actor can define and customize their relations.
+#
+# = Actor subtypes
+# An actor subtype is called a {SocialStream::Models::Subject Subject}.
+# {SocialStream} provides 2 actor subtypes, {User} and {Group}, but the
+# application developer can define as many actor subtypes as required.
+# Actors subtypes are added to +config/initializers/social_stream.rb+
+#
+class Actor < ActiveRecord::Base
+  @subtypes_name = :subject
+  include SocialStream::Models::Supertype
+  include SocialStream::Models::Object
+  
+  delegate :tag_list, :tag_list=, :tagged_with, :tag_counts, :to => :activity_object
+  
+  validates_presence_of :name, :subject_type
+  
+  acts_as_messageable
+
+  acts_as_url :name, :url_attribute => :slug
+  
+  has_one :profile, :dependent => :destroy
+
+  has_many :avatars,
+           :validate => true,
+           :autosave => true
+  has_one  :avatar,
+           :conditions => { :active => true }
+  		  
+  has_many :sent_contacts,
+           :class_name  => 'Contact',
+           :foreign_key => 'sender_id',
+           :dependent   => :destroy
+
+  has_many :received_contacts,
+           :class_name  => 'Contact',
+           :foreign_key => 'receiver_id',
+           :dependent   => :destroy
+
+  has_many :sent_ties,
+           :through => :sent_contacts,
+           :source  => :ties
+  
+  has_many :received_ties,
+           :through => :received_contacts,
+           :source  => :ties
+  
+  has_many :senders,
+           :through => :received_contacts,
+           :uniq => true
+  
+  has_many :receivers,
+           :through => :sent_contacts,
+           :uniq => true
+
+  has_many :relations,
+           :dependent => :destroy
+
+  scope :alphabetic, order('actors.name')
+
+  scope :letter, lambda { |param|
+    if param.present?
+      where('actors.name LIKE ?', "#{ param }%")
+    end
+  }
+
+  scope :name_search, lambda { |param|
+    if param.present?
+      where('actors.name LIKE ?', "%#{ param }%")
+    end
+  }
+  
+  scope :tagged_with, lambda { |param|
+    if param.present?
+      joins(:activity_object).merge(ActivityObject.tagged_with(param))
+    end
+  }
+
+  scope :distinct_initials, select('DISTINCT SUBSTR(actors.name,1,1) as initial').order("initial ASC")
+
+  scope :contacted_to, lambda { |a|
+    joins(:sent_contacts).merge(Contact.active.received_by(a))
+  }
+
+  scope :contacted_from, lambda { |a|
+    joins(:received_contacts).merge(Contact.active.sent_by(a))
+  }
+
+  scope :followed_by, lambda { |a|
+    select("DISTINCT actors.*").
+      joins(:received_ties => { :relation => :permissions }).
+      merge(Contact.sent_by(a)).
+      merge(Permission.follow)
+  }
+
+  after_create :create_initial_relations
+  
+  after_create :save_or_create_profile
+  
+  class << self
+    # Get actor's id from an object, if possible
+    def normalize_id(a)
+      case a
+      when Integer
+        a
+      when Array
+        a.map{ |e| normalize_id(e) }
+      else
+        Actor.normalize(a).id
+      end
+    end
+    # Get actor from object, if possible
+    def normalize(a)
+      case a
+      when Actor
+        a
+      when Integer
+        Actor.find a
+      when Array
+        a.map{ |e| Actor.normalize(e) }
+      else
+        begin
+          a.actor
+        rescue
+          raise "Unable to normalize actor #{ a.inspect }"        
+        end
+      end
+    end
+
+    def find_by_webfinger!(link)
+      link =~ /(acct:)?(.*)@/
+
+      find_by_slug! $2
+    end
+  end
+  
+  #Returning the email address of the model if an email should be sent for this object (Message or Notification).
+  #If the actor is a Group and has no email address, an array with the email of the highest rank members will be
+  #returned isntead.
+  #
+  #If no mail has to be sent, return nil.
+  def mailboxer_email(object)
+    #If actor has disabled the emails, return nil.
+    return nil if !notify_by_email
+    #If actor has enabled the emails and has email
+    return "#{name} <#{email}>" if email.present?
+    #If actor is a Group, has enabled emails but no mail we return the highest_rank ones.
+    if (group = self.subject).is_a? Group
+      relation = group.relation_customs.sort.first
+      receivers = group.contact_actors(:direction => :sent, :relations => relation)
+      emails = Array.new
+      receivers.each do |receiver|
+        receiver_emails = receiver.mailboxer_email(object)
+        case receiver_emails
+        when String
+          emails << receiver_emails
+        when Array
+          receveir_emails.each do |receveir_email|
+            emails << receiver_email
+          end
+        end
+      end
+    return emails
+    end
+  end
+  
+  # The subject instance for this actor
+  def subject
+    subtype_instance
+  end
+
+  # All the {Relation relations} defined by this {Actor}
+  def relation_customs
+    relations.where(:type => 'Relation::Custom')
+  end
+
+  # A given relation defined and managed by this actor
+  def relation_custom(name)
+    relation_customs.find_by_name(name)
+  end
+
+  # The {Relation::Public} for this {Actor} 
+  def relation_public
+    Relation::Public.of(self)
+  end
+
+  # The {Relation::Reject} for this {Actor} 
+  def relation_reject
+    Relation::Reject.of(self)
+  end
+ 
+  # All the {Actor actors} this one has relation with
+  #
+  # Options:
+  # * type: Filter by the class of the contacts.
+  # * direction: sent or received
+  # * relations: Restrict the relations of considered ties. Defaults to {Relation::Custom relations of custom type}
+  # * include_self: False by default, don't include this actor as subject even they have ties with themselves.
+  #
+  def contact_actors(options = {})
+    subject_types   = Array(options[:type] || self.class.subtypes)
+    subject_classes = subject_types.map{ |s| s.to_s.classify }
+    
+    as = Actor.select("DISTINCT actors.*").
+               where('actors.subject_type' => subject_classes).
+               includes(subject_types)
+    
+    
+    case options[:direction]
+      when :sent
+        as = as.joins(:received_ties => :relation).merge(Contact.sent_by(self))
+      when :received
+        as = as.joins(:sent_ties => :relation).merge(Contact.received_by(self))
+    else
+      raise "contact actors in both directions are not supported yet"
+    end
+    
+    if options[:include_self].blank?
+      as = as.where("actors.id != ?", self.id)
+    end
+    
+    if options[:relations].present?
+      as = as.merge(Tie.related_by(options[:relations]))
+    else
+      as = as.merge(Relation.where(:type => ['Relation::Custom', 'Relation::Public']))
+    end
+    
+    as
+  end
+  
+  # All the {SocialStream::Models::Subject subjects} that send or receive at least one {Tie} to this {Actor}
+  #
+  # When passing a block, it will be evaluated for building the actors query, allowing to add 
+  # options before the mapping to subjects
+  #
+  # See #contact_actors for options
+  def contact_subjects(options = {})
+    as = contact_actors(options)
+    
+    if block_given?
+      as = yield(as)
+    end
+    
+    as.map(&:subject)
+  end
+
+  # Return a contact to subject.
+  def contact_to(subject)
+    sent_contacts.received_by(subject).first
+  end
+
+  # Return a contact to subject. Create it if it does not exist
+  def contact_to!(subject)
+    contact_to(subject) ||
+      sent_contacts.create!(:receiver => Actor.normalize(subject))
+  end
+
+  # The {Contact} of this {Actor} to self (totally close!)
+  def ego_contact
+    contact_to!(self)
+  end
+
+  def sent_active_contact_ids
+    @sent_active_contact_ids ||=
+      load_sent_active_contact_ids
+  end
+  
+  # By now, it returns a suggested {Contact} to another {Actor} without any current {Tie}
+  #
+  # @return [Contact]
+  def suggestions(size = 1)
+    candidates = Actor.where(Actor.arel_table[:id].not_in(sent_active_contact_ids + [id]))
+
+    size.times.map {
+      candidates.delete_at rand(candidates.size)
+    }.compact.map { |a|
+      contact_to! a
+    }
+  end
+  
+  # Set of ties sent by this actor received by subject
+  def ties_to(subject)
+    sent_ties.merge(Contact.received_by(subject))
+  end
+
+  # Is there any {Tie} sent by this actor and received by subject
+  def ties_to?(subject)
+    ties_to(subject).present?
+  end
+
+  # The {Tie ties} sent by this actor, plus the second grade ties
+  def egocentric_ties
+    @egocentric_ties ||=
+      load_egocentric_ties
+  end
+
+
+  # Can this actor be represented by subject. Does she has permissions for it?
+  def represented_by?(subject)
+    return false if subject.blank?
+
+    self.class.normalize(subject) == self ||
+      sent_ties.
+        merge(Contact.received_by(subject)).
+        joins(:relation => :permissions).
+        merge(Permission.represent).
+        any?
+  end
+
+  # An {Activity} can be shared with multiple {audicences Audience}, which corresponds to a {Relation}.
+  #
+  # This method returns all the {relations Relation} that this actor can use to broadcast an Activity
+  #
+  #
+  def activity_relations(subject, options = {})
+    return relation_customs if Actor.normalize(subject) == self
+
+    Array.new
+  end
+
+  # Are there any activity_relations present?
+  def activity_relations?(*args)
+    activity_relations(*args).any?
+  end
+
+  # Is this {Actor} allowed to create a comment on activity?
+  #
+  # We are allowing comments from everyone signed in by now
+  def can_comment?(activity)
+    return true
+
+    comment_relations(activity).any?
+  end
+
+  # Are there any relations that allow this actor to create a comment on activity?
+  def comment_relations(activity)
+    activity.relations.select{ |r| r.is_a?(Relation::Public) } |
+      Relation.allow(self, 'create', 'activity', :in => activity.relations)
+  end
+
+  def pending_contacts_count
+    received_contacts.not_reflexive.pending.count
+  end
+
+  def pending_contacts?
+    pending_contacts_count > 0
+  end
+
+  # Build a new {Contact} from each that has not inverse
+  def pending_contacts
+    received_contacts.pending.includes(:inverse).all.map do |c|
+      c.inverse ||
+        c.receiver.contact_to!(c.sender)
+    end
+  end
+
+  # Count the contacts in common between this {Actor} and subject
+  def common_contacts_count(subject)
+    (sent_active_contact_ids & subject.sent_active_contact_ids).size
+  end
+  
+  # The set of {Activity activities} in the wall of this {Actor}.
+  #
+  # There are two types of walls:
+  # home:: includes all the {Activity activities} from this {Actor} and their followed {Actor actors}
+  #             See {Permission permissions} for more information on the following support
+  # profile:: The set of activities in the wall profile of this {Actor}, it includes only the
+  #           activities from the ties of this actor that can be read by the subject
+  #
+  # Options:
+  # :for:: the subject that is accessing the wall
+  # :relation:: show only activities that are attached at this relation level. For example,
+  #             the wall for members of the group.
+  #             
+  def wall(type, options = {})
+    args = {}
+
+    args[:type]  = type
+    args[:owner] = self
+    # Preserve this options
+    [ :for, :object_type ].each do |opt|
+      args[opt]   = options[opt]
+    end
+
+    if type == :home
+      args[:followed] = Actor.followed_by(self).map(&:id)
+    end
+
+    # TODO: this is not scalling for sure. We must use a fact table in the future
+    args[:relation_ids] =
+      case type
+      when :home
+        # The relations from followings that can be read
+        Relation.allow(self, 'read', 'activity').map(&:id)
+      when :profile
+        # FIXME: options[:relation]
+        #
+        # The relations that can be read by options[:for]
+        options[:for].present? ?
+          Relation.allow(options[:for], 'read', 'activity').map(&:id) :
+          []
+      else
+        raise "Unknown type of wall: #{ type }"
+      end
+
+    Activity.wall args
+  end
+ 
+  def logo
+    avatar!.logo
+  end
+
+  def avatar!
+    avatar || avatars.build
+  end
+  
+  # The 'like' qualifications emmited to this actor
+  def likes
+    Activity.joins(:activity_verb).where('activity_verbs.name' => "like").
+             joins(:activity_objects).where('activity_objects.id' => activity_object_id)
+  end
+  
+  def liked_by(subject) #:nodoc:
+    likes.joins(:contact).merge(Contact.sent_by(subject))
+  end
+  
+  # Does subject like this {Actor}?
+  def liked_by?(subject)
+    liked_by(subject).present?
+  end
+  
+  # Build a new activity where subject like this
+  def new_like(subject)
+    a = Activity.new :verb => "like",
+                     :contact => subject.contact_to!(self),
+                     :relation_ids => Array(subject.relation_public.id)
+    
+    a.activity_objects << activity_object           
+                    
+    a             
+  end
+  
+  # Use slug as parameter
+  def to_param
+    slug
+  end
+  
+  private
+  
+  # After create callback
+  def create_initial_relations
+    Relation::Custom.defaults_for(self)
+    Relation::Public.default_for(self)
+    Relation::Reject.default_for(self)
+  end
+
+  # After create callback
+  #
+  # Save the profile if it is present. Otherwise create it
+  def save_or_create_profile
+    if profile.present?
+      profile.actor_id = id
+      profile.save!
+    else
+      create_profile
+    end
+  end
+
+  # Calculate {#egocentric_ties}
+  def load_egocentric_ties
+    ties = sent_ties.includes(:contact).to_a
+
+    contact_ids = ties.map{ |t| t.contact.receiver_id }
+
+    second_grade_ties =
+      contact_ids.
+        map{ |i| Tie.sent_by(i) }.
+        flatten
+
+    ties + second_grade_ties
+  end
+
+  # Calculate {#sent_active_contact_ids}
+  def load_sent_active_contact_ids
+    sent_contacts.active.map(&:receiver_id)
+  end
+end