social_stream-base 0.5.2 → 0.6.0

data/app/models/tie.rb

@@ -1,23 +1,8 @@
-# A {Tie} is a link between two {Actor Actors} with a {Relation}.
+# A {Tie} is a link between two {Actor Actors} ({Contact}) 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
@@ -43,44 +28,26 @@
 # 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 :contact, :counter_cache => true
 
-  belongs_to :relation
+  has_one :sender,   :through => :contact
+  has_one :receiver, :through => :contact
 
-  has_many :tie_activities, :dependent => :destroy
-  has_many :activities, :through => :tie_activities
+  belongs_to :relation
 
   scope :recent, order("ties.created_at DESC")
 
   scope :sent_by, lambda { |a|
-    where(:sender_id => Actor.normalize_id(a))
+    joins(:contact).merge(Contact.sent_by(a))
   }
-
   scope :received_by, lambda { |a|
-    where(:receiver_id => Actor.normalize_id(a))
+    joins(:contact).merge(Contact.received_by(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))))
+    joins(:contact).merge(Contact.sent_or_received_by(a))
   }
 
   scope :related_by, lambda { |r|
@@ -89,226 +56,59 @@ class Tie < ActiveRecord::Base
     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 :with_permissions, lambda { |action, object|
+    joins(:relation => :permissions).
+      where('permissions.action' => action).
+      where('permissions.object' => object)
   }
 
-  scope :intended, where(:intended => true)
-
-  validates_presence_of :sender_id, :receiver_id, :relation
-
-  before_validation :find_or_build_relation
+  validates_presence_of :contact_id, :relation_id
 
-  before_create :save_relation
+  validate :relation_belongs_to_sender
 
+  after_create  :create_activity
   after_create  :increment_follower_count
   after_destroy :decrement_follower_count
 
   def relation_name
-    @relation_name || relation.try(:name)
-  end
-
-  def relation!
-    relation ||
-      find_relation
+    relation.try(:name)
   end
 
   def sender_subject
-    sender.try(:subject)
+    sender.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
+    receiver.subject
   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?
+  # before_create callback
+  #
+  # Create contact activity if this is the first tie
+  def create_activity
+    return unless contact.ties_count == 1
 
-    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?
+    Activity.create! :contact => contact,
+                     :relation_ids => contact.relation_ids,
+                     :activity_verb => ActivityVerb[contact.verb]
   end
 
   # after_create callback
   #
   # Increment the {Actor}'s follower_count
   def increment_follower_count
-    return if reflexive? ||
+    return if contact.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?
+    return if Tie.sent_by(sender).
+                  received_by(receiver).
+                  with_permissions('follow', nil).
+                  where("ties.id != ?", id).
+                  present?
 
     receiver.increment!(:follower_count)
   end
@@ -317,16 +117,21 @@ class Tie < ActiveRecord::Base
   #
   # Decrement the {Actor}'s follower_count
   def decrement_follower_count
-    return if reflexive? ||
+    return if contact.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?
+    return if Tie.sent_by(sender).
+                  received_by(receiver).
+                  with_permissions('follow', nil).
+                  present?
 
     receiver.decrement!(:follower_count)
   end
+
+  def relation_belongs_to_sender
+    errors.add(:relation, "Relation must belong to sender") unless
+      contact.sender_id == relation.actor_id
+  end
 end

data/app/models/user.rb

@@ -19,15 +19,15 @@ class User < ActiveRecord::Base
   end
   
   def recent_groups
-    contacts(:type => :group, :direction => :sent) do |q|
-      q.select("ties.created_at").
-        merge(Tie.recent)
+    contact_subjects(:type => :group, :direction => :sent) do |q|
+      q.select("contacts.created_at").
+        merge(Contact.recent)
     end
   end
 
   # Subjects this user can acts as
   def represented
-    contacts(:direction => :received) do |q|
+    contact_subjects(:direction => :received) do |q|
       q.joins(:sent_ties => { :relation => :permissions }).merge(Permission.represent)
     end
   end
@@ -38,6 +38,10 @@ class User < ActiveRecord::Base
   def password_required?
     !persisted? || !password.nil? || !password_confirmation.nil?
   end
+
+     def find_first(options)
+      raise options.inspect
+    end
   
   class << self
     %w( email slug name ).each do |a|
@@ -50,8 +54,8 @@ class User < ActiveRecord::Base
     end                                    # end
       EOS
     end
-    
-    # Overwrite devise default find method to support login with email,
+
+   # Overwrite devise default find method to support login with email,
     # presence ID and login
     def find_for_authentication(conditions)
       if ( login = conditions[:email] ).present?
@@ -64,10 +68,10 @@ class User < ActiveRecord::Base
         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)
+
+    def find_or_initialize_with_errors(required_attributes, attributes, error=:invalid)
+      if required_attributes == [:email]
+        find_or_initialize_with_error_by_email(attributes[:email], error)
       else
         super
       end

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

@@ -10,13 +10,17 @@
 <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')%>
+		<% SocialStream.activity_forms.each do |element| %>
+			<div id="header_<%= element %>" class="activities_title_header">	
+	      		<%= image_tag("btn/"+element.to_s+".png") %> <%=t(element.to_s+'.title')%>
+			</div>
+		<% end %> 	
     </div>
     <%= render :partial => 'activities/new', :locals => { :receiver => owner } %>
   </div>
 
   <div id="wall">
     <%= render activities  %>
-    <%= will_paginate activities %>
+    <%= paginate activities %>
   </div>
-</div>
+</div>

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

@@ -1,9 +1,34 @@
+//initial state
+$('#wrapper_activities_header form').hide();
+$('#new_post').show();
+
+//clicks on headers
+$('.activities_title_header').live('click',function(){
+	$('.activities_title_header').removeClass('selected');
+	$(this).addClass('selected');
+	$('#wrapper_activities_header form').hide();
+	$('#new_'+this.id.split("_")[1]).show();
+});
+
+//submit
+$('#masterSubmitButton').live('click',function(){
+	$('.liveAdded').remove();
+	$('#wrapper_activities_header form:visible').append(
+	$('<input/>')
+	  .addClass('liveAdded')
+	  .attr('type', 'hidden')
+	  .attr('name', $('#wrapper_activities_header form:visible')
+	  .attr('id').split('_')[1]+'[_relation_ids][]')
+	  .val($('#security option:selected').attr('value')));
+	$('#wrapper_activities_header form:visible').submit();
+});
+
 //javascript for main activities input
 title = "<%= t('activity.input') %>";
 $("#input_activities").click(function(){
   if(this.value == title){
     this.value="";
-    $("#activities_share_btn").show();
+    $("#masterSubmitButton").show();
   }
 });
 

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

@@ -1,30 +1,25 @@
-<% if receiver.activity_ties_for?(current_subject) %>
+<% if can? :create, new_activity(receiver) %>
   <% 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").dropdownchecklist( { closeRadioOnClick: true, forceMultiple: false } );
     $("#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">
+<div id="activities_header" class="content_size">
+  <% SocialStream.activity_forms.each do |element| %>
+    <%= render :partial => element.to_s.pluralize+'/new',
+               :locals  => {
+                             :receiver => receiver
+                           } %>
+  <% end %>
+</div>
 
-        <% 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>
+<div id="activities_share_btn">
+<div id="securities"><%= select_tag :_relation_ids, grouped_options_for_select(current_subject.grouped_activity_relations(receiver)), :id => 'security', :multiple => nil %></div>
+<%= submit_tag(t('share'), :class => "myButtonBlue", :id => "masterSubmitButton") %>
+</div>
 <% end %>

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

@@ -1,7 +1,7 @@
 <div class="activity_options">
   <ul class="activity_options" >
     <li><div class="post_time_ago"><%= t('time.ago', :time => time_ago_in_words(activity.created_at)) %></div></li>
-    <% if activity.is_root? && activity.receiver.activity_ties_for?(current_subject) %>
+    <% if activity.is_root? && current_subject.activity_relations?(activity.receiver, :in => activity.relations) %>
     <li><div class="verb_comment"> · <%= link_to t('activity.to_comment'), "#", :class => "to_comment" %> </div></li>
     <% end %>
     <li><div class="verb_like" id="like_<%= dom_id(activity) %>"> · <%= link_like(activity)%></div></li>

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

@@ -23,7 +23,7 @@
                :locals => { :owner      => owner,
                             :activities => owner.wall(:profile,
                                                       :for => current_subject).
-                                                 paginate(:page => params[:page]) } %>
+                                                 page(params[:page]) } %>
   </div>
 
   <% owner.relation_customs.sort.each do |r| %>

data/app/views/avatars/index.html.erb

@@ -2,11 +2,12 @@
 
 <% content_for :headers do %>
   <%= stylesheet_link_tag "avatars.css", :media => "screen, projection" %>
-  <%= javascript_include_tag 'avatars.js' %>
   <%= javascript_include_tag 'jquery.Jcrop.min' %>
   <%= javascript_include_tag 'jquery.form' %>
   <%= javascript_include_tag 'jquery.fileupload' %>
   <%= javascript_include_tag 'jquery.fileupload-ui' %>
+  <%= javascript_include_tag 'avatars.js' %>
+
   <%= stylesheet_link_tag "jquery.Jcrop", :media => "screen, projection" %>
   <%= stylesheet_link_tag "avatars", :media => "screen, projection" %><br/>
   <%= stylesheet_link_tag "jquery.fileupload-ui", :media => "screen, projection" %>

data/app/views/avatars/update.js.erb

@@ -0,0 +1,15 @@
+$("#avatar_img_<%= old_id %>").removeClass("default");
+$("#avatar_img_<%= old_id %>").addClass("non_default");
+$("#avatar_link_<%= old_id %>").show();
+
+$("#avatar_img_<%= new_id %>").removeClass("non_default");
+$("#avatar_img_<%= new_id %>").addClass("default");
+$("#avatar_link_<%= new_id %>").hide();
+
+representation_path = $("#avatar_img_<%= new_id %>").attr('src').replace("/profile/", "/representation/");  
+
+$('#current_user_avatar_img').attr('src', representation_path);
+$('#current_subject_avatar_img').css('background-image', "url('" + representation_path +"')");
+
+$("#current_avatar_img").attr('src', $("#avatar_img_<%= new_id %>").attr('src') );
+  

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

@@ -1,19 +1,23 @@
-<% if activity.receiver.activity_ties_for?(current_subject) %>
+<% if user_signed_in? && current_subject.can_comment?(activity) %>
   <div class="activity_new_comment">
  <%= form_for Comment.new(:text => t('comment.input'),
-                          :_activity_tie_id =>
-                            activity.receiver.activity_ties_for(current_subject).first.id,
+                          :_contact_id =>
+                            current_subject.contact_to!(activity.receiver).id,
                           :_activity_parent_id => activity.id
               ),
           :html => { :class => "new_comment", :id => "new_comment"+dom_id(activity)  },
           :remote => true do |f| %>
-   <%= f.hidden_field :_activity_tie_id,  :id => "activity_receiver_tie_from_id_"+dom_id(activity) %>
-   <%= f.hidden_field :_activity_parent_id, :id => "activity_id_"+dom_id(activity) %>
+   <% current_subject.comment_relations(activity).each do |r| %>
+     <%= f.hidden_field "_relation_ids][", :id => "comment__relation_ids_#{ r.id }", :value => r.id %>
+   <% end %>
+   <%= f.hidden_field :_activity_parent_id %>
+
    <%= f.text_field :text,   :class =>"input_new_comments" , :id => "comment_text_"+dom_id(activity) %>
+
    <div class="activities_comment_btn">
      <div class="activities_security"></div>
      <%= f.submit t('share'), :class =>"myButtonBlue", :id => "comment_submit"+dom_id(activity) %>
    </div>
  <% end %>
     </div>
-<% end %>
+<% end %>

data/app/views/contacts/_contact.html.erb

@@ -11,7 +11,7 @@
       <%= contact_brief(contact.receiver_subject) %>
     </div>
     <div class="link" id="contact_link<%= dom_id(contact.receiver_subject)%>">
-      <%= new_contact_link(contact) %>
+      <%= contact_to(contact.receiver) %>
     </div>
   </div>
   <div class="close"><%=link_to('X','#')%></div>