social_stream-base 0.5.0

data/app/controllers/posts_controller.rb

@@ -0,0 +1,11 @@
+class PostsController < InheritedResources::Base
+  load_and_authorize_resource
+
+  respond_to :html, :xml, :js
+
+  def destroy
+    @post_activity = resource.post_activity
+
+    destroy!
+  end
+end

data/app/controllers/profiles_controller.rb

@@ -0,0 +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/relation/customs_controller.rb

@@ -0,0 +1,16 @@
+class Relation::CustomsController < InheritedResources::Base
+  before_filter :authenticate_user!
+  load_and_authorize_resource :class => Relation::Custom
+
+  respond_to :js
+
+  belongs_to :sphere, :optional => true
+
+  def index
+    # Must authorize index, because Cancan does not filter collection with conditions.
+    # See https://github.com/ryanb/cancan/wiki/checking-abilities
+    authorize! :read, parent.customs.new
+
+    index!
+  end
+end

data/app/controllers/spheres_controller.rb

@@ -0,0 +1,12 @@
+class SpheresController < InheritedResources::Base
+  before_filter :authenticate_user!
+  load_and_authorize_resource
+
+  respond_to :html, :js
+
+  protected
+
+  def begin_of_association_chain
+    current_subject
+  end
+end

data/app/controllers/subjects_controller.rb

@@ -0,0 +1,7 @@
+class SubjectsController < ApplicationController
+  def lrdd
+    actor = Actor.find_by_webfinger!(params[:id])
+
+    redirect_to polymorphic_path(actor.subject, :format => :xrd)
+  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

@@ -0,0 +1,30 @@
+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|
+      format.html { render :layout => (user_signed_in? ? 'application' : 'frontpage') }
+    end
+  end
+
+  # Supported through devise
+  def new; end; def create; end
+  # Not supported yet
+  def destroy; end
+
+  protected
+
+  # Overwrite resource method to support slug
+  # See InheritedResources::BaseHelpers#resource
+  def resource
+    @user ||= end_of_association_chain.find_by_slug!(params[:id])
+  end
+end

data/app/helpers/activities_helper.rb

@@ -0,0 +1,21 @@
+module ActivitiesHelper
+  
+  # Link to 'like' or 'unlike' depending on the like status of the activity to current_subject
+  # 
+  # @param [Object]
+  # @return [String]
+  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
+      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/helpers/contacts_helper.rb

@@ -0,0 +1,26 @@
+module ContactsHelper
+  def contact_brief(contact)
+    "N contacts in common"
+  end
+
+  # Show current ties from current user to actor, if they exist, or provide a link
+  # to create new ties to actor
+  def contact_to(a)
+    if user_signed_in?
+      if current_subject.ties_to(a).present?
+        current_subject.ties_to(a).map(&:relation_name).join(", ")
+      else
+        new_contact_link(Contact.new(current_subject, a))
+      end
+    else
+      link_to t("contact.new.link"), new_user_session_path
+    end
+  end
+
+  def new_contact_link(contact)
+    link_to t("contact.new.link"),
+            new_contact_path(:id => contact.to_param),
+            :title => t("contact.new.title",
+                        :name => contact.receiver.name)
+  end
+end

data/app/helpers/groups_helper.rb

@@ -0,0 +1,3 @@
+module GroupsHelper
+
+end

data/app/helpers/location_helper.rb

@@ -0,0 +1,48 @@
+module LocationHelper
+  
+  # Renders the location stack for your view. You can add as many stack levels as you wish.
+  #
+  # Usage:  
+  # <%= location(level1,leve2,level3,level4,....) %> 
+  #
+  # Output: 
+  # base > level1 > level2 > level3 > level 4
+  #
+  # Default configuration:
+  # base => "You are here" ("location.base" on config/locales)
+  # separator => ">" ("location.separator" on config/locales)
+  #
+  # Styles and HTML wrapping:
+  # partial => location/_location.html.erb 
+  #
+  # Example:  
+  # 	Render a location with a two leves depth:
+  #
+  #   	<%= location(link_to(leve1.name, level1.url),link_to(leve2.name, level2.url)) %>
+  #
+  def location(*stack)
+    location_body = t('location.base')
+    stack.collect {|level|
+      location_body << t('location.separator') + level
+    }
+    
+    location_div = capture do
+      render :partial => "location/location", :locals=>{:location_body => location_body}
+    end
+    
+    case request.format
+      when Mime::JS
+      response = <<-EOJ
+
+          $('#map_location').html("#{ escape_javascript(location_div) }");
+          EOJ
+      
+      response.html_safe
+    else
+      content_for(:location) do
+        location_div
+      end
+    end
+    
+  end
+end

data/app/helpers/notifications_helper.rb

@@ -0,0 +1,23 @@
+module NotificationsHelper
+  def decode_notification notification_text, activity
+    if activity.tie.present?
+      notification_text = notification_text.gsub(/\%\{sender\}/,link_to(activity.tie.sender.name,activity.tie.sender.subject))
+      notification_text = notification_text.gsub(/\%\{sender.name\}/,activity.tie.sender.name)
+    elsif activity._tie.present?
+      notification_text = notification_text.gsub(/\%\{sender\}/,link_to(activity._tie.sender.name,activity._tie.sender.subject))
+      notification_text = notification_text.gsub(/\%\{sender.name\}/,activity._tie.sender.name)
+    end
+
+      if activity.direct_object.present?
+        object = activity.direct_object
+        object = object.subject if object.is_a? Actor
+        notification_text=notification_text.gsub(/\%\{object\}/,link_to(object.class.to_s.downcase,object))
+        notification_text=notification_text.gsub(/\%\{object.name\}/,object.class.to_s.downcase)
+      else
+        notification_text=notification_text.gsub(/\%\{object\}/,"nilclass")
+        notification_text=notification_text.gsub(/\%\{object.name\}/,"nilclass")
+      end
+
+    notification_text
+  end
+end

data/app/helpers/permissions_helper.rb

@@ -0,0 +1,16 @@
+module PermissionsHelper
+  DEFAULT_PERMISSIONS =
+    [
+      [ "read",    "activity", "weak_star_ties" ],
+      [ "create",  "activity", nil ],
+      [ "follow", nil, nil],
+      [ "represent", nil, nil]
+    ]
+
+  def default_permissions
+    @default_permissions ||=
+      DEFAULT_PERMISSIONS.map{ |p|
+        Permission.find_or_create_by_action_and_object_and_function *p
+      }
+  end
+end

data/app/helpers/profiles_helper.rb

@@ -0,0 +1,31 @@
+module ProfilesHelper
+  
+  #Tells if the current subject accessing the profile is its owner or not
+  def is_owner?
+    if (current_subject.present?) and (@profile.present?) and (@profile.actor == current_subject.actor)
+      return true
+    else
+      return false
+    end
+  end
+  
+  #Returns true if the "Personal Information" section is empty
+  def is_personal_empty?
+    if (@profile.organization?) or (@profile.birthday?) or (@profile.city?) or (@profile.description?)
+      return false
+    else
+      return true
+    end
+  end
+  
+  #Returns true if the "Personal Information" section is empty
+  def is_contact_empty?
+    if (@profile.phone?) or (@profile.mobile?) or (@profile.fax?) or (@profile.address?)or 
+       (@profile.website?) or (@profile.subject.email?)
+      return false
+    else
+      return true
+    end
+  end
+  
+end

data/app/helpers/subjects_helper.rb

@@ -0,0 +1,6 @@
+module SubjectsHelper
+  # Return a link to this subject with the name
+  def link_name(subject, options = {})
+    link_to subject.name, subject, options
+  end
+end

data/app/helpers/toolbar_helper.rb

@@ -0,0 +1,83 @@
+module ToolbarHelper
+  # Define the toolbar content for your view. There are two typical cases, depending on the value of
+  # options[:profile]
+  # * If present, render the profile menu for the {SocialStream::Models::Subject subject}
+  # * If blank, render the home menu
+  #
+  # The menu option allows overwriting a menu slot with the content of the given block
+  #
+  #
+  # Autoexpanding a menu section on your view:
+  #
+  # Toolbar allows you to autoexpand certain menu section that may be of interest for your view.
+  # For example, the messages menu when you are looking your inbox. This is done through :option element.
+  #
+  # To get it working, you should use the proper :option to be expanded, ":option => :messages" in the
+  # mentioned example. This will try, automatically, to expand the section of the menu where its root
+  # list link, the one expanding the section, has an id equal to "#messages_menu". If you use
+  # ":options => :contacts" it will try to expand "#contacts_menu".
+  #
+  # For now its working with :option => :messages, :contacts or :groups
+  #
+  #
+  # Examples:
+  #
+  # Render the home toolbar:
+  #
+  #   <% toolbar %>
+  #
+  # Render the profile toolbar for a user:
+  #
+  #   <% toolbar :profile => @user %>
+  #
+  # Render the home toolbar changing the messages menu option:
+  #
+  #   <% toolbar :option => :messages %>
+  #
+  # Render the profile toolbar for group changing the contacts menu option:
+  #
+  #   <% toolbar :profile => @group, :option => :contacts %>
+  #
+
+  def toolbar(options = {}, &block)
+    if options[:option] && block_given?
+      menu_options[options[:option]] = capture(&block)
+    end
+
+    content = capture do
+      if options[:profile]
+        render :partial => 'toolbar/profile', :locals => { :subject => options[:profile] }
+      else
+        render :partial => 'toolbar/home'
+      end
+    end
+
+    case request.format
+    when Mime::JS
+      response = <<-EOJ
+
+		      $('#toolbar').html("#{ escape_javascript(content) }");
+		      initMenu();
+		      expandSubMenu('#{ options[:option] }');
+		      EOJ
+
+      response.html_safe
+    else
+      content_for(:toolbar) do
+        content
+      end
+      content_for(:javascript) do
+        <<-EOJ
+        expandSubMenu('#{ options[:option] }');
+        EOJ
+      end
+    end
+  end
+
+  # Cache menu options for toolbar
+  #
+  # @api private
+  def menu_options #:nodoc:
+    @menu_options ||= {}
+  end
+end

data/app/helpers/users_helper.rb

@@ -0,0 +1,4 @@
+module UsersHelper
+
+
+end

data/app/models/ability.rb

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

data/app/models/activity.rb

@@ -0,0 +1,198 @@
+# Activities follow the {Activity Streams}[http://activitystrea.ms/] standard.
+#
+# == Activities and Ties
+# Every activity is attached to a Tie, which defines the sender, the receiver and
+# the relation in which the activity is transferred
+#
+# == Wall
+# The Activity.wall(type, ties) scope provides all the activities attached to a set of ties
+#
+# There are two types of wall, :home and :profile. Check {Actor#wall} for more information
+#
+class Activity < ActiveRecord::Base
+  has_ancestry
+
+  belongs_to :activity_verb
+
+  has_many :tie_activities, :dependent => :destroy
+  has_many :ties, :through => :tie_activities
+
+  has_one :tie,
+          :through => :tie_activities,
+          :conditions => { 'tie_activities.original' => true }
+
+  delegate :relation, :to => :tie
+
+  has_many :activity_object_activities,
+           :dependent => :destroy
+  has_many :activity_objects,
+           :through => :activity_object_activities
+
+  scope :wall, lambda { |type, ties|
+    q = select("DISTINCT activities.*").
+          roots.
+          joins(:tie_activities).
+          where('tie_activities.tie_id' => ties).
+          order("created_at desc")
+
+    # Profile wall is composed by original TieActivities. Not original are copies for followers
+    if type == :profile
+      q = q.where('tie_activities.original' => true)
+    end
+
+    q
+  }
+
+  # After an activity is created, it is disseminated to follower ties
+  attr_accessor :_tie
+  after_create :disseminate_to_ties
+
+  after_create  :increment_like_count
+  after_destroy :decrement_like_count
+  
+  #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
+    tie.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
+    tie.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
+    tie.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
+    tie.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(:ties).where('tie_activities.original' => true).merge(Tie.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",
+    :_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
+  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 }.#{ tie.receiver.subject_type }.title",
+      :subject => view.link_name(sender_subject),
+      :contact => view.link_name(receiver_subject)
+    when "post"
+      view.link_name sender_subject
+    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 _tie.sender!=_tie.receiver
+      notification_subject = actionview.render :partial => 'notifications/activities/' + verb + "_subject", :locals => {:activity => self}
+      notification_body = actionview.render :partial =>  'notifications/activities/' + verb + "_body", :locals => {:activity => self}
+      _tie.receiver.notify(notification_subject, notification_body, self)
+    end
+    true
+  end
+
+  private
+
+  # Assign to ties of followers
+  def disseminate_to_ties
+    # Create the original sender tie_activity
+    tie_activities.create!(:tie => _tie)
+  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
+end

data/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
+  has_one  :actor
+
+  # The object of this activity object
+  def object
+    subtype_instance ||
+      actor.try(:subject)
+  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/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/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