social_stream 0.4.3 → 0.4.4

data/app/controllers/api_controller.rb

@@ -26,7 +26,7 @@ class ApiController < ApplicationController
     end
     
     @page = params[:page]
-    @activities = @user.wall(:home).paginate(:page => params[:page], :per_page => 10)
+    @activities = @user.wall(:profile).paginate(:page => params[:page], :per_page => 10)
     respond_to do |format|
       format.atom
     end

data/app/controllers/contacts_controller.rb

@@ -8,7 +8,7 @@ class ContactsController < ApplicationController
           q.alphabetic.
             letter(params[:letter]).
             search(params[:search]).
-            merge(Tie.original.related_by(current_subject.relations.find_by_id(params[:relation])))
+            merge(Tie.related_by(current_subject.relations.find_by_id(params[:relation])))
         }
 
     respond_to do |format|

data/app/controllers/conversations_controller.rb

@@ -15,9 +15,9 @@ class ConversationsController < ApplicationController
 
   def show
     if @box.eql? 'trash'
-      @receipts = @conversation.receipts(@actor).trash
+      @receipts = @mailbox.receipts_for(@conversation).trash
     else
-      @receipts = @conversation.receipts(@actor).not_trash
+      @receipts = @mailbox.receipts_for(@conversation).not_trash
     end
     render :action => :show
     @receipts.mark_as_read
@@ -41,14 +41,14 @@ class ConversationsController < ApplicationController
     end
 
     if params[:reply_all].present?
-      last_receipt = @conversation.receipts(@actor).last
+      last_receipt = @mailbox.receipts_for(@conversation).last
       @receipt = @actor.reply_to_all(last_receipt, params[:body])
     end
 
     if @box.eql? 'trash'
-      @receipts = @conversation.receipts(@actor).trash
+      @receipts = @mailbox.receipts_for(@conversation).trash
     else
-      @receipts = @conversation.receipts(@actor).not_trash
+      @receipts = @mailbox.receipts_for(@conversation).not_trash
     end
     render :action => :show
     @receipts.mark_as_read

data/app/controllers/groups_controller.rb

@@ -7,6 +7,7 @@ class GroupsController < InheritedResources::Base
     @groups = Group.alphabetic.
                     letter(params[:letter]).
                     search(params[:search]).
+                    tagged_with(params[:tag]).
                     paginate(:per_page => 10, :page => params[:page])
 
     index! do |format|

data/app/controllers/likes_controller.rb

@@ -1,10 +1,10 @@
 class LikesController < ApplicationController
-  before_filter :authenticate_user!
+  before_filter :authenticate_user!, :indirect_object
 
   # POST /activities/1/like.js
   def create
-    @like = Like.new(current_subject, params[:activity_id])
-
+    @like = Like.build(current_subject, @indirect_id)
+    
     respond_to do |format|
       if @like.save
         format.js
@@ -16,8 +16,8 @@ class LikesController < ApplicationController
 
   # DELETE /activities/1/like.js
   def destroy
-    @like = Like.find!(current_subject, params[:activity_id])
-
+    @like = Like.find!(current_subject, @indirect_id)
+    
     respond_to do |format|
       if @like.destroy
         format.js
@@ -26,4 +26,16 @@ class LikesController < ApplicationController
       end
     end
   end
+  
+  private
+  
+  def indirect_object
+    if params[:activity_id].present?
+     @indirect_id = Activity.find(params[:activity_id])
+    elsif params[:user_id].present?
+     @indirect_id = User.find_by_slug!(params[:user_id])
+    elsif params[:group_id].present?
+     @indirect_id = Group.find_by_slug!(params[:group_id])
+    end
+  end
 end

data/app/controllers/messages_controller.rb

@@ -1,5 +1,6 @@
 class MessagesController < ApplicationController
 
+  before_filter :authenticate_user!
 	before_filter :get_mailbox, :get_box, :get_actor
 	
 	def index
@@ -46,6 +47,7 @@ class MessagesController < ApplicationController
 		@receipt = @actor.send_message(@recipients, params[:body], params[:subject])
 		if (@receipt.errors.blank?)
 			@conversation = @receipt.conversation
+      flash[:success]="Your message was sent"
 			redirect_to conversation_path(@conversation, :box => :sentbox)
 		else
 			render :action => :new
@@ -77,7 +79,7 @@ class MessagesController < ApplicationController
 	def get_box
 		if params[:box].blank? or !["inbox","sentbox","trash"].include?params[:box]
 			@box = "inbox"
-		return
+		  return
 		end
 		@box = params[:box]
 	end

data/app/controllers/profiles_controller.rb

@@ -1,5 +1,9 @@
 class ProfilesController < InheritedResources::Base
   belongs_to_subjects(:singleton => true)
+
+  load_and_authorize_resource :profile,
+                              :through => SocialStream.subjects,
+                              :singleton => true
   
   respond_to :html, :xml, :js
 end

data/app/controllers/representations_controller.rb

@@ -1,8 +1,19 @@
 # Changes context for users to represent other subjects
 class RepresentationsController < ApplicationController
+  before_filter :load_representation
+
+  authorize_resource
+
   def create
-    self.current_subject = Representation.new(params[:representation]).subject
+    self.current_subject = @representation.subject
 
     redirect_to(request.referer || home_path)
   end
+
+  private
+
+  # Build representation from params
+  def load_representation
+    @representation = Representation.new(params[:representation])
+  end
 end

data/app/controllers/tags_controller.rb

@@ -0,0 +1,15 @@
+class TagsController < ApplicationController
+  before_filter :authenticate_user!
+  
+  def index
+    @tags = ActsAsTaggableOn::Tag.where('name like ?','%'+params[:tag]+'%').limit(10)
+    response = @tags.map{ |t| { 'key' => t.name, 'value' => t.name } }.to_json
+    if @tags.count == 0
+      response = "[{\"key\":\""+params[:tag]+"\" , \"value\":\""+params[:tag]+"\"}]"
+    end
+
+    respond_to do |format|
+      format.json { render :text => response}
+    end
+  end
+end

data/app/controllers/users_controller.rb

@@ -1,10 +1,13 @@
 class UsersController < InheritedResources::Base
+  load_and_authorize_resource
+
   respond_to :html, :xml, :js
   
   def index
     @users = User.alphabetic.
                   letter(params[:letter]).
                   search(params[:search]).
+                  tagged_with(params[:tag]).
                   paginate(:per_page => 10, :page => params[:page])
 
     index! do |format|

data/app/helpers/activities_helper.rb

@@ -1,14 +1,21 @@
 module ActivitiesHelper
-
+  
   # Link to 'like' or 'unlike' depending on the like status of the activity to current_subject
   # 
-  # @param [Activity]
+  # @param [Object]
   # @return [String]
-  def link_like(activity)
-    if (activity.liked_by?(current_subject))
-      link_to t('activity.unlike'), activity_like_path(activity), :method => :delete, :remote => true
+  def link_like(object)
+    if !user_signed_in?
+      link_to image_tag("btn/nolike.png", :class => "menu_icon")+ 
+                t('activity.like'),new_user_session_path
     else
-      link_to t('activity.like'), activity_like_path(activity), :method => :post, :remote => true
+      if (object.liked_by?(current_subject))
+        link_to image_tag("btn/like.png", :class => "menu_icon")+ 
+                t('activity.unlike'), [object, :like], :method => :delete, :remote => true
+      else
+        link_to image_tag("btn/nolike.png", :class => "menu_icon")+ 
+                t('activity.like'), [object, :like], :method => :post, :remote => true
+      end
     end
   end
 end

data/app/models/activity.rb

@@ -10,12 +10,6 @@
 # There are two types of wall, :home and :profile. Check {Actor#wall} for more information
 #
 class Activity < ActiveRecord::Base
-  # The direction of the sender and receiver subjects compared with the attached tie
-  SUBJECT_DIRECTIONS = {
-    :direct  => %w(follow make-friend),
-    :inverse => %w(like post update)
-  }
-
   has_ancestry
 
   belongs_to :activity_verb
@@ -34,8 +28,8 @@ class Activity < ActiveRecord::Base
   has_many :activity_objects,
            :through => :activity_object_activities
 
-  after_create :like_direct_object
-
+  after_create :send_notifications
+  
   scope :wall, lambda { |type, ties|
     q = select("DISTINCT activities.*").
           roots.
@@ -51,9 +45,9 @@ class Activity < ActiveRecord::Base
     q
   }
 
-  # After an activity is created, it is associated to ties
+  # After an activity is created, it is disseminated to follower ties
   attr_accessor :_tie
-  after_create :assign_to_ties
+  after_create :disseminate_to_ties
 
   # The name of the verb of this activity
   def verb
@@ -70,7 +64,7 @@ class Activity < ActiveRecord::Base
   # This method provides the {Actor}. Use {#sender_subject} for the {SocialStream::Models::Subject Subject}
   # ({User}, {Group}, etc..)
   def sender
-    direct? ? tie.sender : tie.receiver
+    tie.sender 
   end
 
   # The {SocialStream::Models::Subject Subject} author of this activity
@@ -78,7 +72,7 @@ class Activity < ActiveRecord::Base
   # This method provides the {SocialStream::Models::Subject Subject} ({User}, {Group}, etc...).
   # Use {#sender} for the {Actor}.
   def sender_subject
-    direct? ? tie.sender_subject : tie.receiver_subject
+    tie.sender_subject
   end
 
   # The wall where the activity is shown belongs to receiver
@@ -86,7 +80,7 @@ class Activity < ActiveRecord::Base
   # This method provides the {Actor}. Use {#receiver_subject} for the {SocialStream::Models::Subject Subject}
   # ({User}, {Group}, etc..)
   def receiver
-    direct? ? tie.receiver : tie.sender
+    tie.receiver
   end
 
   # The wall where the activity is shown belongs to the receiver
@@ -94,7 +88,7 @@ class Activity < ActiveRecord::Base
   # This method provides the {SocialStream::Models::Subject Subject} ({User}, {Group}, etc...).
   # Use {#receiver} for the {Actor}.
   def receiver_subject
-    direct? ? tie.receiver_subject : tie.sender_subject
+    tie.receiver_subject
   end
 
   # The comments about this activity
@@ -108,7 +102,7 @@ class Activity < ActiveRecord::Base
   end
 
   def liked_by(user) #:nodoc:
-    likes.joins(:ties).where('tie_activities.original' => true).merge(Tie.received_by(user))
+    likes.joins(:ties).where('tie_activities.original' => true).merge(Tie.sent_by(user))
   end
 
   # Does user like this activity?
@@ -118,9 +112,14 @@ class Activity < ActiveRecord::Base
 
   # Build a new children activity where subject like this
   def new_like(subject)
-    children.new :verb => "like",
-                 :_tie => subject.sent_ties(:receiver => receiver,
-                                            :relation => relation).first
+    a = children.new :verb => "like",
+                     :_tie => subject.sent_ties(:receiver => receiver).first
+
+    if direct_activity_object.present? 
+      a.activity_objects << direct_activity_object
+    end
+    
+    a
   end
 
   # The first activity object of this activity
@@ -136,7 +135,7 @@ class Activity < ActiveRecord::Base
   # The title for this activity in the stream
   def title view
     case verb
-    when "follow", "make-friend"
+    when "follow", "make-friend", "like"
       I18n.t "activity.verb.#{ verb }.#{ tie.receiver.subject_type }.title",
              :subject => view.link_name(sender_subject),
              :contact => view.link_name(receiver_subject)
@@ -144,47 +143,49 @@ class Activity < ActiveRecord::Base
       view.link_name sender_subject
     end.html_safe
   end
+  
+  def notificable?
+    return true if is_root?
+    return true if ['post','update'].include? root.verb
+    #return false if ['follow','like','make_friend'].include? root.verb #Not necessary 
+    return false 
+  end
+  
+  def notify
+    return nil if !notificable?
+        #Avaible verbs: follow, like, make-friend, post, update
+    case verb
+    when 'like'
+      #Like a SUBJECT
+      
+      #Like an OBJECT
+      
+    when 'follow','make_friend'
+      #Follow or Make friend with a SUBJECT
+      receipts = _tie.receiver.notify(I18n.t("activity.verb." + verb + "." + _tie.receiver_subject.class.to_s + ".notification.subject", :name => _tie.sender.name),
+      I18n.t("activity.verb." + verb + "." + _tie.receiver_subject.class.to_s + ".notification.body", :name => _tie.sender.name))
+    when 'post','update'
+      #Post or udapte an OBJECT
+      if _tie.sender!=_tie.receiver
+        receipts = _tie.receiver.notify(I18n.t("activity.verb." + verb + "." + _tie.receiver_subject.class.to_s + ".notification.subject", :name => _tie.sender.name, :direct_object => direct_object.class.to_s),
+        I18n.t("activity.verb." + verb + "." + _tie.receiver_subject.class.to_s + ".notification.body", :name => _tie.sender.name, :direct_object => direct_object.class.to_s))        
+      end      
+    end
+  end
 
   private
 
   # Assign to ties of followers
-  def assign_to_ties
-    original = tie_activities.create!(:tie => _tie)
-
-    # All the ties following the activities attached to this tie, allowed to read
-    # this activity
-    Tie.following([_tie.sender_id, _tie.receiver_id]).each do |t|
-      if _tie.allows?(t.sender_id, 'read', 'activity')
-        tie_activities.create!(:tie => t,
-                               :original => false)
-      end
-    end
+  def disseminate_to_ties
+    # Create the original sender tie_activity
+    tie_activities.create!(:tie => _tie)
   end
 
-  # Link like activities with parent direct object
-  def like_direct_object
-    return unless verb == "like"
-
-    return if parent.direct_object.blank?
-
-    activity_objects << parent.direct_activity_object
-  end
 
   private
 
-  # The {#sender} and the {#receiver} of the {Activity} depends on its {ActivityVerb}
-  #
-  # Contact activities such as make-friend or follow are direct. They have the same sender
-  # and receiver as their tie. On the other hand, post activities are inverse. The sender of
-  # the activity is the receiver of the tie and the receiver of the activity is the sender of
-  # the tie
-  def direct?
-    if SUBJECT_DIRECTIONS[:direct].include?(verb)
-      true
-    elsif SUBJECT_DIRECTIONS[:inverse].include?(verb)
-      false
-    else
-      raise "Unknown direction for verb #{ verb }"
-    end
+  #Send notifications to actors based on proximity, interest and permissions
+  def send_notifications
+    notify
   end
 end

data/app/models/activity_object.rb

@@ -12,6 +12,8 @@ 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
   has_one  :actor

data/app/models/actor.rb

@@ -14,16 +14,19 @@ class Actor < ActiveRecord::Base
   @subtypes_name = :subject
   include SocialStream::Models::Supertype
   
+  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
+           :validate => true,
+           :autosave => true
   		  
   has_many :sent_ties,
            :class_name => "Tie",
@@ -43,6 +46,10 @@ class Actor < ActiveRecord::Base
            :through => :sent_ties,
            :uniq => true
 
+  has_many :spheres
+
+  has_many :relations, :through => :spheres
+
   scope :alphabetic, order('actors.name')
 
   scope :letter, lambda { |param|
@@ -56,6 +63,12 @@ class Actor < ActiveRecord::Base
       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")
 
@@ -121,15 +134,15 @@ class Actor < ActiveRecord::Base
     Tie.sent_or_received_by(self)
   end
   
-  # Relations defined and managed by this actor
-  def relations
-    Relation.includes(:ties).merge(Tie.sent_by(self))
-  end
-  
   # A given relation defined and managed by this actor
   def relation(name)
     relations.find_by_name(name)
   end
+
+  # The {Relation::Public} for this {Actor} 
+  def relation_public
+    Relation::Public.of(self)
+  end
   
   # All the {Actor actors} this one has relation with
   #
@@ -229,18 +242,39 @@ class Actor < ActiveRecord::Base
   
   # Set of ties sent by this actor received by a
   def ties_to(a)
-    sent_ties.received_by(a).original
+    sent_ties.received_by(a)
+  end
+
+  # Get the first of the ties created to a, or create a new one with the {Relation::Public}
+  def ties_to!(a)
+    ties_to(a).present? ?
+      ties_to(a) :
+      Array(sent_ties.create!(:receiver => a,
+                              :relation => relation_public))
   end
   
   def ties_to?(a)
     ties_to(a).present?
   end
-  
-  # All the ties this actor has with subject that support permission
-  def sent_ties_allowing(subject, action, objective)
+
+  # The sent {Tie ties} by this {Actor} that grant subject the permission to perform action on object
+  def allow(subject, action, object = nil)
     return [] if subject.blank?
-    
-    sent_ties.allowing(subject, action, objective)
+
+    sent_ties.allowing(subject, action, object)
+  end
+
+  # Does this {Actor} have any {Tie} to subject that grants her the permission of performing action on object
+  def allow?(subject, action, object = nil)
+    allow(subject, action, object).any?
+  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 ||
+      allow?(subject, 'represent')
   end
 
   # The ties that allow attaching an activity to them. This method is used for caching
@@ -248,10 +282,17 @@ class Actor < ActiveRecord::Base
     @active_ties ||= {}
   end
 
-  # The ties that allow subject creating activities for this actor
-  def active_ties_for(subject)
+  # This {Actor} #allow s subject to create activities and subject has at least one tie to subject
+  def activity_ties_for(subject)
     active_ties[subject] ||=
-      sent_ties_allowing(subject, 'create', 'activity')
+      ( allow?(subject, 'create', 'activity') ?
+        subject.ties_to!(self) :
+        [] )
+  end
+
+  # Is there any {Tie} for subject to create an activity to this {Actor} ?
+  def activity_ties_for?(subject)
+    activity_ties_for(subject).any?
   end
 
   def pending_ties
@@ -278,8 +319,7 @@ class Actor < ActiveRecord::Base
     ts = ties
 
     if type == :profile
-      # FIXME: show public activities
-      return [] if options[:for].blank?
+      return ties.public_relation if options[:for].blank?
 
       ts = ts.allowing(options[:for], 'read', 'activity')
     end
@@ -299,10 +339,36 @@ class Actor < ActiveRecord::Base
     avatars.active.first || 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(:ties).where('tie_activities.original' => true).merge(Tie.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",
+                     :_tie => subject.ties_to(self).first
+    
+    a.activity_objects << activity_object           
+                    
+    a             
+  end
+  
   private
   
   # After create callback
   def create_initial_relations
-    Relation.defaults_for(self)
+    Relation::Custom.defaults_for(self)
+    Relation::Public.default_for(self)
   end
 end

data/app/models/avatar.rb

@@ -2,7 +2,8 @@ require 'RMagick'
 
 class Avatar < ActiveRecord::Base
  	has_attached_file :logo,
-                      :styles => { :tie => "30x30>",
+                      :styles => { :representation => "20x20>",
+                                   :tie => "30x30>",
                                    :actor => '35x35>',
                                    :profile => '94x94' },
                       :default_url => "/images/logos/:style/:subtype_class.png"

data/app/models/like.rb

@@ -1,34 +1,49 @@
 # Convenience class for managing like activities
 class Like
-  attr_reader :activity
+  attr_reader :object
 
   class << self
     # Find the children activity of activity_id liked by subject
-    def find(subject, activity_id)
-      find_activity(activity_id).liked_by(subject).first
+    def find(subject, object)
+      like = new(object.liked_by(subject).first)
+      # Cache object to make it available before it is destroyed
+      like.object
+      like
     end
 
     # Like #find but raises error if not found
-    def find!(subject, activity_id)
-      find(subject, activity_id) ||
+    def find!(subject, object)
+      find(subject, object) ||
         raise(ActiveRecord::RecordNotFound)
     end
 
-    # Find the activity that is liked
-    def find_activity(id)
-      Activity.find(id) ||
-        raise(ActiveRecord::RecordNotFound)
+    def build(subject, object)
+       new object.new_like(subject)
     end
   end
 
   # Initialize a new like activity
-  def initialize(subject, activity_id)
-    @subject  = subject
-    @activity = self.class.find_activity(activity_id)
-    @like     = @activity.new_like(@subject)
+  def initialize(activity)
+    @like = activity
   end
 
   def save
     @like.save
   end
+  
+  # The object that is liked. It can be an activity
+  def object
+    @object ||=
+      if @like.is_root?
+        obj = @like.direct_object
+        obj = obj.subject if obj.is_a?(Actor)
+        obj
+      else
+        @like.parent
+      end
+  end
+  
+  def destroy
+    @like.destroy
+  end
 end