social_stream-base 0.5.0

data/app/models/tie.rb

@@ -0,0 +1,332 @@
+# A {Tie} is a link between two {Actor Actors} with a {Relation}.
+#
+# The first {Actor} is the sender of the {Tie}. The second {Actor}
+# is the receiver of the {Tie}.
+#
+# = {Tie Ties} and {Activity activities}
+# {Activity Activities} are attached to {Tie ties}. When _Alice_ post in _Bob_'s wall,
+# the {Activity} is attached to the {Tie} from _Alice_ to _Bob_
+#
+# * The sender of the {Tie} is the author of the {Activity}.
+#   It is the user that uploads a resource to the website or the social entity that
+#   originates the {Activity} (for example: add as contact).
+#
+# * The receiver {Actor} of the {Tie} is the receiver of the {Activity}.
+#   The {Activity} will appear in the wall of the receiver, depending on the permissions
+#
+# * The {Relation} sets up the mode in which the {Activity} is shared.
+#   It sets the rules, or {Permission Permissions}, by which {Actor} have access
+#   to the {Activity}.
+#
+# = Tie strengh
+#
+# Because each {Tie} belongs to a {Relation} and {Relation Relations} have strength
+# hierarchies, {Tie Ties} also have them. A {Tie} is stronger than other if its
+# {Relation} is stronger than the other's. For example, if _Alice_ has a _friend_ {Tie}
+# with _Bob_, and an _acquaintance_ {Tie} with _Charlie_, given that _friend_ {Relation}
+# is stronger than _acquaintance_, the {Tie} with _Bob_ is stronger than the {Tie} with
+# _Charlie_.
+#
+# = Authorization
+# When an {Actor} establishes a {Tie} with other, she is granting a set of
+# {Permission Permissions} to them (posting to her wall, reading her posts, etc..)
+# The set of {Permission Permissions} granted are associated with the {Relation} of
+# the {Tie}.
+#
+# Usually, stronger ties (and relations) have more permissions than weaker ones.
+#
+# = Scopes
+# There are several scopes defined:
+#
+# sent_by(actor):: ties whose sender is actor
+# received_by(actor):: ties whose receiver is actor
+# sent_or_received_by(actor):: the union of the former
+# related_by(relation):: ties with this relation. Accepts relation, relation_name,
+#                        integer, array
+# replied:: ties having at least another tie in the other way, a tie from a to b
+#           is replied if there is a tie from b to a
+# intended:: ties can be desactivated by subjects when they change their connections.
+#            This scope gathers the active ones
+#
+class Tie < ActiveRecord::Base
+  # Facilitates relation assigment along with find_relation callback
+  attr_writer :relation_name
+  # Facilitates new relation permissions assigment along with find_or build_relation callback
+  attr_accessor :relation_sphere, :relation_permissions
+  # Send a message when this tie is created
+  attr_accessor :message
+
+  belongs_to :sender,
+             :class_name => "Actor",
+             :include => SocialStream.subjects
+  belongs_to :receiver,
+             :class_name => "Actor",
+             :include => SocialStream.subjects
+
+  belongs_to :relation
+
+  has_many :tie_activities, :dependent => :destroy
+  has_many :activities, :through => :tie_activities
+
+  scope :recent, order("ties.created_at DESC")
+
+  scope :sent_by, lambda { |a|
+    where(:sender_id => Actor.normalize_id(a))
+  }
+
+  scope :received_by, lambda { |a|
+    where(:receiver_id => Actor.normalize_id(a))
+  }
+
+  scope :sent_or_received_by, lambda { |a|
+    where(arel_table[:sender_id].eq(Actor.normalize_id(a)).
+          or(arel_table[:receiver_id].eq(Actor.normalize_id(a))))
+  }
+
+  scope :related_by, lambda { |r|
+    if r.present?
+      where(:relation_id => Relation.normalize_id(r))
+    end
+  }
+
+  scope :replied, lambda {
+    select("DISTINCT ties.*").
+      from("ties, ties as ties_2").
+      where("ties.sender_id = ties_2.receiver_id AND ties.receiver_id = ties_2.sender_id")
+  }
+
+  scope :replying, lambda { |tie|
+    where(:sender_id => tie.receiver_id).
+    where(:receiver_id => tie.sender_id)
+  }
+
+  scope :following, lambda { |a|
+    where(:receiver_id => Actor.normalize_id(a)).
+      joins(:relation => :permissions).merge(Permission.follow)
+  }
+
+  scope :public_relation, lambda {
+    joins(:relation).where('relations.type' => 'Relation::Public')
+  }
+
+  scope :intended, where(:intended => true)
+
+  validates_presence_of :sender_id, :receiver_id, :relation
+
+  before_validation :find_or_build_relation
+
+  before_create :save_relation
+
+  after_create  :increment_follower_count
+  after_destroy :decrement_follower_count
+
+  def relation_name
+    @relation_name || relation.try(:name)
+  end
+
+  def relation!
+    relation ||
+      find_relation
+  end
+
+  def sender_subject
+    sender.try(:subject)
+  end
+
+  def receiver_subject
+    receiver.try(:subject)
+  end
+
+  # Does this tie have the same sender and receiver?
+  def reflexive?
+    sender_id == receiver_id
+  end
+
+  # Is there any tie from receiver to sender?
+  def replied?
+    receiver.ties_to?(sender)
+  end
+ 
+  # The set of ties between sender and receiver
+  #
+  # Options::
+  # * relations: Only ties with relations
+  def relation_set(options = {})
+    set = self.class.where(:sender_id => sender_id,
+                           :receiver_id => receiver_id)
+
+    if options.key?(:relations)
+      set = 
+        set.related_by Relation.normalize_id(options[:relations],
+                                             :sender => sender)
+    end
+
+    set
+  end
+
+  # The tie with relation r inside this relation_set
+  def related(r)
+    relation_set(:relations => r).first
+  end
+
+  # = Access Control
+  #
+  # Access control enforcement in ties come from the permissions assigned to other ties through relations.
+  # The access_set is the set of ties that grant some permission on a particular tie.
+  #
+  # Enforcing access control on activities and ties are a matter of finding its access set.
+  # There are two approaches for this, checking the permissions on particular tie or finding all the ties
+  # granted some permission.
+  #
+  # == Particular tie
+  # ------------------        ------------------
+  # | particular tie |--------|   access_set   |
+  # |       t        |        |      ties      |
+  # ------------------        ------------------
+  #
+  # Because t is given, the scopes are applied to the ties table
+  # We get the set of ties that allow permission on t
+  #
+  # == Finding ties
+  # ------------------  join  ------------------
+  # |  finding ties  |--------|   access_set   |
+  # |      ties      |        |     ties_as    |
+  # ------------------        ------------------
+  #
+  # Because we want to find ties, an additional join table (ties_as) is needed for applying access set conditions
+  # We get the set of ties that are allowing certain permission
+  #
+
+  # Given a given permission (action, object), the access_set are the set of ties that grant that permission.
+  scope :access_set, lambda { |tie, action, object|
+    with_permissions(action, object).
+      where(Permission.parameter_conditions(tie))
+  }
+
+  scope :allowing_set, lambda { |action, object|
+    query = 
+      select("DISTINCT ties.*").
+        from("ties INNER JOIN relations ON relations.id = ties.relation_id, ties as ties_as INNER JOIN relations AS relations_as ON relations_as.id = ties_as.relation_id INNER JOIN relation_permissions ON relations_as.id = relation_permissions.relation_id INNER JOIN permissions ON permissions.id = relation_permissions.permission_id").
+        where("permissions.action" => action).
+        where("permissions.object" => object)
+
+    conds = Permission.parameter_conditions
+    # FIXME: Patch to support public activities
+    if action == 'read' && object == 'activity'
+      conds = "( #{ conds } ) OR #{ sanitize_sql('relations.type' => 'Relation::Public') }"
+    end
+
+    query.where(conds)
+  }
+
+  scope :allowing, lambda { |actor, action, object|
+    allowing_set(action, object).
+      where("ties_as.receiver_id" => Actor.normalize_id(actor))
+  }
+
+  # The set of ties that permit this tie allow to allow action on object
+  def access_set(action, object)
+    self.class.access_set(self, action, object)
+  end
+
+  # The set of ties allowing user to perform action on object
+  def allowing(user, action, object)
+    access_set(action, object).received_by(user)
+  end
+
+  # Does this tie allows user to perform action on object?
+  #
+  # We allow all actions on reflexive ties
+  def allow?(user, action, object)
+    return true if Actor.normalize_id(user) == sender_id && reflexive?
+
+    # FIXME: Patch to support public activities.
+    if relation.is_a?(Relation::Public)
+      return relation.allow?(user, action, object)
+    end
+
+    allowing(user, action, object).any?
+  end
+
+  scope :with_permissions, lambda { |action, object|
+    joins(:relation => :permissions).
+      where('permissions.action' => action).
+      where('permissions.object' => object)
+  }
+
+  # All the ties that are allowed to follow activities from this tie
+  def followers
+    followers = Tie.received_by(sender).with_permissions('follow', nil)
+
+    unless relation.is_a?(Relation::Public)
+      allowed = access_set('read', 'activity').map(&:receiver_id)
+
+      followers = followers.sent_by(allowed)
+    end
+
+    followers
+  end
+
+  private
+
+  # Before validation callback
+  # Assigns relation or builds it based on the param
+  def find_or_build_relation
+    return if find_relation || relation_name.blank?
+
+    self.relation = Relation::Custom.new :name   => relation_name,
+                                         :sphere => nil
+
+    relation.permission_ids = relation_permissions
+  end
+
+  # Infers relation from its name and the type of the actors
+  def find_relation
+    return if relation_name.blank?
+
+    if relation_name == relation.try(:name)
+      relation
+    elsif sender.present?
+      self.relation = sender.relation_custom(relation_name)
+    end
+ end
+ 
+  def save_relation
+    relation.save! if relation.new_record?
+  end
+
+  # after_create callback
+  #
+  # Increment the {Actor}'s follower_count
+  def increment_follower_count
+    return if reflexive? ||
+              !relation.permissions.include?(Permission.follow.first)
+
+    # Because we allow several ties from the same sender to the same receiver,
+    # we check the receiver does not already have a follower tie from this sender
+    return if sender.sent_ties.
+                     received_by(receiver).
+                     with_permissions('follow', nil).
+                     where("ties.id != ?", id).
+                     present?
+
+    receiver.increment!(:follower_count)
+  end
+
+  # after_destroy callback
+  #
+  # Decrement the {Actor}'s follower_count
+  def decrement_follower_count
+    return if reflexive? ||
+              !relation.permissions.include?(Permission.follow.first)
+
+    # Because we allow several ties from the same sender to the same receiver,
+    # we check the receiver does not still have a follower tie from this sender
+    return if sender.sent_ties.
+                     received_by(receiver).
+                     with_permissions('follow', nil).
+                     present?
+
+    receiver.decrement!(:follower_count)
+  end
+end

data/app/models/tie_activity.rb

@@ -0,0 +1,42 @@
+class TieActivity < ActiveRecord::Base
+  belongs_to :activity
+  belongs_to :tie
+
+  after_create :disseminate
+
+  private
+  
+  # Make a copy to all the ties that are both interesed and allowed to reach the activity
+  def disseminate
+    return unless original?
+
+    followers = tie.followers
+
+    # FIXME: here we need to check moderation and diffussion of the received activity.
+    #
+    # Sometimes, diffussion is not required, i.e. when the sender adds the receiver as contact
+    # Other times, the receiver must explicitly allow to post to her wall, and the dissemination permissions
+    # can control who else related with the receiver should receive the activity
+    receiver_ties =
+      Tie.
+        with_permissions('create', 'activity').
+        replying(tie)
+
+    if receiver_ties.present?
+      followers |= receiver_ties
+
+      # Disseminate to the followers of the receiver
+      receiver_ties.each do |t|
+        followers |= t.followers
+      end
+    end
+
+    # All the ties following the activities attached to this tie, allowed to read
+    # this activity
+    followers.each do |t|
+      self.class.create!(:activity_id => activity_id,
+                         :tie => t,
+                         :original => false)
+    end
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,125 @@
+require 'devise/orm/active_record'
+
+class User < ActiveRecord::Base
+  has_many :authentications
+  devise *SocialStream.devise_modules
+
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :name, :email, :password, :password_confirmation, :remember_me, :profile_attributes
+  
+  validates_presence_of :email
+
+  validates_format_of :email, :with => Devise.email_regexp, :allow_blank => true
+  # TODO: uniqueness of email, which is in actor
+  
+  with_options :if => :password_required? do |v|
+    v.validates_presence_of     :password
+    v.validates_confirmation_of :password
+    v.validates_length_of       :password, :within => Devise.password_length, :allow_blank => true
+  end
+  
+  def recent_groups
+    contacts(:type => :group, :direction => :sent) do |q|
+      q.select("ties.created_at").
+        merge(Tie.recent)
+    end
+  end
+
+  # Subjects this user can acts as
+  def represented
+    contacts(:direction => :received) do |q|
+      q.joins(:sent_ties => { :relation => :permissions }).merge(Permission.represent)
+    end
+  end
+  
+  protected
+  
+  # From devise
+  def password_required?
+    !persisted? || !password.nil? || !password_confirmation.nil?
+  end
+  
+  class << self
+    %w( email slug name ).each do |a|
+      eval <<-EOS
+    def find_by_#{ a }(#{ a })             # def find_by_email(email)
+      find :first,                         #   find(:first,
+           :include => :actor,             #         :include => :actor,
+           :conditions =>                  #         :conditions =>
+             { 'actors.#{ a }' => #{ a } } #           { 'actors.email' => email }
+    end                                    # end
+      EOS
+    end
+    
+    # Overwrite devise default find method to support login with email,
+    # presence ID and login
+    def find_for_authentication(conditions)
+      if ( login = conditions[:email] ).present?
+        if login =~ /@/
+          find_by_email(login)
+        else
+          find_by_slug(login)
+        end
+      else
+        super
+      end
+    end
+    
+    def find_or_initialize_with_error_by(attribute, value, error=:invalid)
+      if attribute == :email
+        find_or_initialize_with_error_by_email(value, error)
+      else
+        super
+      end
+    end
+    
+    # Overwrite devise default method to support finding with actor.email
+    def find_or_initialize_with_error_by_email(value, error)
+      if value.present?
+        record = find_by_email(value)
+      end
+      
+      unless record
+        record = new
+        
+        if value.present?
+          record.email = value
+        else
+          error = :blank
+        end
+        
+        record.errors.add(:email, error)
+      end
+      
+      record
+    end
+
+    def find_or_create_for_facebook_oauth(access_token,signed_in_resource=nil)
+      data = access_token['extra']['user_hash']
+      print data
+      auth = Authentication.find_by_provider_and_uid(access_token["provider"],access_token["uid"])
+      user = User.find_by_email(data["email"])
+      
+      if user == nil
+        user = User.create!(:name => data["name"], :email => data["email"], :password => Devise.friendly_token[0,20])
+      end
+      if auth == nil
+        auth = Authentication.create!(:user_id => user.id, :uid =>access_token["uid"], :provider => access_token["provider"])
+      end
+      user
+    end
+    
+    def find_or_create_for_linkedin_oauth(access_token,signed_in_resource=nil)
+      auth = Authentication.find_by_uid_and_provider(access_token["uid"],access_token["provider"])
+      if auth==nil
+        user = User.create!(:name => access_token["user_info"]["name"], :email => 'demo@socialstream.com', :password => Devise.friendly_token[0,20])
+        auth = Authentication.create!(:user_id => user.id, :uid =>access_token["uid"], :provider => access_token["provider"])
+        user
+      else
+        user = User.find_by_id(auth.user_id)
+        user
+      end
+    end
+    
+  end
+end

data/app/views/activities/_activity.html.erb

@@ -0,0 +1,5 @@
+<% if activity.is_root? %>
+  <%= render :partial => "activities/root", :locals => { :activity => activity } %>
+<% else %>
+  <%= render :partial => "activities/child", :locals => { :activity => activity } %>
+<% end %>

data/app/views/activities/_child.html.erb

@@ -0,0 +1,18 @@
+<%= div_for activity, :class => "subactivity" do %>
+  <div class="actor_logo_subactivity">
+    <%= link_to image_tag(activity.sender_subject.logo.url(:actor),
+                          :alt => activity.sender_subject.name),
+                 activity.sender_subject %>
+  </div>
+  <div class="activity_content">
+    <div class="actor_name-activity_objects">
+      <%= link_to(activity.sender_subject.name, activity.sender_subject) %>
+      <span class="subactivity_objects">
+        <%= render activity.activity_objects %>
+      </span>
+    </div>
+    <%= render :partial => 'activities/options',
+               :locals => { :activity => activity } %>
+  </div>
+<% end %>
+<div class="space_comments"></div>

data/app/views/activities/_comments.html.erb

@@ -0,0 +1,3 @@
+<div class="activity_comments" id="comments_<%= dom_id(activity) %>">
+  <%= render activity.comments %>
+</div>

data/app/views/activities/_index.html.erb

@@ -0,0 +1,22 @@
+<% content_for :headers do %>
+  <%= stylesheet_link_tag "activities", :media => "screen, projection" %>
+  <%= stylesheet_link_tag "jquery-ui", :media => "screen, projection" %>
+<% end %>
+
+<% content_for :javascript do %>
+  <%= render :partial => 'activities/jquery' %>
+<% end -%>
+
+<div id="wrapper_activities">
+  <div id="wrapper_activities_header">
+    <div id="activities_title" class="content_size">
+      <%= image_tag("btn/btn_activities.png") %> <%=t('activity.other')%>
+    </div>
+    <%= render :partial => 'activities/new', :locals => { :receiver => owner } %>
+  </div>
+
+  <div id="wall">
+    <%= render activities  %>
+    <%= will_paginate activities %>
+  </div>
+</div>

data/app/views/activities/_jquery.html.erb

@@ -0,0 +1,100 @@
+//javascript for main activities input
+title = "<%= t('activity.input') %>";
+$("#input_activities").click(function(){
+  if(this.value == title){
+    this.value="";
+    $("#activities_share_btn").show();
+  }
+});
+
+
+//javascript for comments
+$(".input_new_comments").val("<%= t('comment.input') %>");
+$(".activities_comment_btn").hide();
+
+//usa livequery para usar el javascript luego de una accion con  AJAX
+$(".input_new_comments").livequery("click",function(){
+	if(this.value == "<%= t('comment.input') %>"){
+		$(this).val("");
+	}
+	$(".activities_comment_btn").hide();
+	$(this).parent(".new_comment").children(".activities_comment_btn").show();
+});
+$(".input_new_comments").livequery("blur",function(){
+	if(this.value == ""){
+		$(".activities_comment_btn").hide();
+    $(this).val("<%= t('comment.input') %>");
+	}
+});
+
+$(".input_new_comments").click(function(){
+	if(this.value == "<%= t('comment.input') %>"){
+		$(this).val("");
+	}
+	$(".activities_comment_btn").hide();
+	$(this).parent(".new_comment").children(".activities_comment_btn").show();
+});
+
+//javascript for tocomment option
+$(".to_comment").livequery("click", function(){
+  $(this).parents(".activity_content").find(".input_new_comments").click();
+  $(this).parents(".activity_content").find(".input_new_comments").focus();
+	return false;
+});
+$(".to_comment").livequery("blur", function(){
+  $(this).parents(".activity_content").find(".input_new_comments").blur();
+	return false;
+});
+
+
+
+
+
+
+
+
+
+//move he last list item before the first item. The purpose of this is if the user clicks to slide left he will be able to see the last item.
+$('#carousel_ul li:first').before($('#carousel_ul li:last'));
+
+
+//when user clicks the image for sliding right
+$('#right_scroll img').livequery("click",function(){
+
+  //get the width of the items ( i like making the jquery part dynamic, so if you change the width in the css you won't have o change it here too ) '
+  var item_width = $('#carousel_ul li').outerWidth() + 10;
+
+  //calculae the new left indent of the unordered list
+  var left_indent = parseInt($('#carousel_ul').css('left')) - item_width;
+
+  //make the sliding effect using jquery's anumate function '
+  $('#carousel_ul:not(:animated)').animate({'left' : left_indent},500,function(){
+
+      //get the first list item and put it after the last list item (that's how the infinite effects is made) '
+      $('#carousel_ul li:last').after($('#carousel_ul li:first'));
+
+      //and get the left indent to the default -210px
+      $('#carousel_ul').css({'left' : '-210px'});
+  });
+});
+
+//when user clicks the image for sliding left
+$('#left_scroll img').livequery("click",function(){
+
+  var item_width = $('#carousel_ul li').outerWidth() + 10;
+
+  /* same as for sliding right except that it's current left indent + the item width (for the sliding right it's - item_width) */
+  var left_indent = parseInt($('#carousel_ul').css('left')) + item_width;
+
+  $('#carousel_ul:not(:animated)').animate({'left' : left_indent},500,function(){
+
+  /* when sliding to left we are moving the last item before the first list item */
+  $('#carousel_ul li:first').before($('#carousel_ul li:last'));
+
+  /* and again, when we make that change we are setting the left indent of our unordered list to the default -210px */
+  $('#carousel_ul').css({'left' : '-210px'});
+  });
+
+
+});
+

data/app/views/activities/_new.html.erb

@@ -0,0 +1,30 @@
+<% if receiver.activity_ties_for?(current_subject) %>
+  <% content_for :javascript do %>
+
+    securityImage = "<%= escape_javascript(image_tag('btn/btn_security.png', :id => 'security_image', :alt => 'security')) %>";
+    downImage = "<%= escape_javascript(image_tag('btn/btn_down.png')) %>";
+
+    $("#security").dropdownchecklist( { closeRadioOnClick: true } );
+    $("#security_image").parent().width(28);
+    $("#security_image").parent().parent().width(28);
+  <% end %>
+
+  <div id="activities_header" class="content_size">
+    <%= form_for Post.new(:text => t('activity.input'),
+                          :_activity_tie_id => receiver.activity_ties_for(current_subject).first.id),
+                          :remote => true  do |f| %>
+      <%= f.text_field :text, :id => "input_activities", :size => 85 %>
+      <div id="activities_share_btn">
+
+        <% if receiver.activity_ties_for(current_subject).count > 1 %>
+          <div id="securities">
+            <%= f.select :_activity_tie_id, receiver.activity_ties_for(current_subject).sort{ |t, u| t.relation <=> u.relation }.map{ |t| [ t.relation_name, t.id ] }, {}, :id => 'security' %>
+          </div>
+        <% else %>
+          <%= f.hidden_field :_activity_tie_id %>
+        <% end %>
+        <%= f.submit t('share'), :class =>"myButtonBlue" %>
+      </div>
+    <% end -%>
+  </div>
+<% end %>