social_stream 0.0.1

data/app/models/relation_permission.rb

@@ -0,0 +1,4 @@
+class RelationPermission < ActiveRecord::Base
+  belongs_to :relation
+  belongs_to :permission
+end

data/app/models/tie.rb

@@ -0,0 +1,207 @@
+# A link between two actors in a relation.
+#
+# The first Actor is the sender of the Tie. The second Actor is the receiver of the Tie.
+#
+# == Ties and Activities
+# Activities are attached to ties. 
+# * The sender actor 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.
+# * The receiver is the target of the Activity. The wall-profile of an actor is
+#   composed by the resources assigned to the ties in which the actor is the receiver.
+# * The Relation sets up the mode in which the Activity is shared. It sets the rules,
+#    or permissions, by which actors have access to the Activity.
+# 
+# == Inverse ties
+# Relations can have its inverse. When a tie is establised, an inverse tie is establised
+# as well.
+#
+# == 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
+# * inverse(tie), the inverse of tie
+#
+class Tie < ActiveRecord::Base
+  # Avoids loops at create_inverse after save callback
+  attr_accessor :_without_inverse
+  attr_protected :_without_inverse
+
+  # Facilitates relation assigment along with find_relation callback
+  attr_accessor :relation_name
+
+  validates_presence_of :sender_id, :receiver_id, :relation_id
+
+  belongs_to :sender,
+             :class_name => "Actor",
+             :include => SocialStream.actors
+  belongs_to :receiver,
+             :class_name => "Actor",
+             :include => SocialStream.actors
+  belongs_to :relation
+
+  has_many :activities
+
+  scope :sent_by, lambda { |a|
+    where(:sender_id => Actor_id(a))
+  }
+
+  scope :received_by, lambda { |a|
+    where(:receiver_id => Actor_id(a))
+  }
+
+  scope :sent_or_received_by, lambda { |a|
+    where(arel_table[:sender_id].eq(Actor_id(a)).
+          or(arel_table[:receiver_id].eq(Actor_id(a))))
+
+  }
+
+  scope :inverse, lambda { |t|
+    sent_by(t.receiver).
+      received_by(t.sender).
+      where(:relation_id => t.relation.inverse_id)
+  }
+
+  def sender_subject
+    sender.try(:subject)
+  end
+
+  def receiver_subject
+    receiver.try(:subject)
+  end
+
+  before_validation :find_relation
+
+  scope :pending, includes(:relation) & Relation.request
+
+  # The set of ties between sender and receiver
+  #
+  def relation_set(r = :nil)
+    set = self.class.where(:sender_id => sender_id,
+                           :receiver_id => receiver_id)
+
+    case r
+    when :nil
+      set
+    when String
+      set.where(:relation_id => relation.mode.find_by_name(r))
+    else
+      set.where(:relation_id => r)
+    end
+  end
+
+  # The tie with relation r inside this relation_set
+  def related(r)
+    relation_set(r).first
+  end
+
+  after_create :complete_weak_set, :create_inverse
+
+  # Access Control
+
+  scope :with_permissions, lambda { |action, object|
+    includes(:relation => :permissions).
+      where('permissions.action' => action).
+      where('permissions.object' => object)
+  }
+
+  scope :parameterized, lambda { |tie|
+    where(tie_conditions(tie).
+          or(weak_set_conditions(tie)).
+          or(group_set_conditions(tie)).
+          or(weak_group_set_conditions(tie)))
+  }
+
+  scope :access_set, lambda { |tie, action, object|
+    with_permissions(action, object).
+      parameterized(tie)
+  }
+
+
+  def permissions(user, action, object)
+    self.class.
+      sent_by(user).
+      access_set(self, action, object)
+  end
+
+  def permission?(user, action, object)
+    permissions(user, action, object).any?
+  end
+
+  class << self
+    def tie_conditions(t)
+      arel_table[:sender_id].eq(t.sender_id).and(
+        arel_table[:receiver_id].eq(t.receiver_id)).and(
+        arel_table[:relation_id].eq(t.relation_id)).and(
+        Permission.arel_table[:parameter].eq('tie'))
+    end
+
+    def weak_set_conditions(t)
+      arel_table[:sender_id].eq(t.sender_id).and(
+        arel_table[:receiver_id].eq(t.receiver_id)).and(
+        arel_table[:relation_id].in(t.relation.stronger_or_equal)).and(
+        Permission.arel_table[:parameter].eq('weak_set'))
+    end
+
+    def group_set_conditions(t)
+      arel_table[:receiver_id].eq(t.receiver_id).and(
+        arel_table[:relation_id].eq(t.relation_id)).and(
+        Permission.arel_table[:parameter].eq('group_set'))
+    end
+
+    def weak_group_set_conditions(t)
+      arel_table[:receiver_id].eq(t.receiver_id).and(
+        arel_table[:relation_id].in(t.relation.stronger_or_equal)).and(
+        Permission.arel_table[:parameter].eq('weak_group_set'))
+    end
+  end
+
+  private
+
+  # Before validation callback
+  # Infers relation from its name and the type of the actors
+  def find_relation
+    if relation_name.present?
+      self.relation = Relation.mode(sender_subject.class.to_s,
+                                    receiver_subject.class.to_s).
+                                    find_by_name(relation_name)
+    end
+  end
+
+  # After create callback
+  # Creates ties with a weaker relations in the strength hierarchy of this tie
+  def complete_weak_set
+    relation.weaker.each do |r|
+      if relation_set(r).blank?
+        t = relation_set.build :relation => r
+        t._without_inverse = true
+        t.save!
+      end
+    end
+  end
+
+  # After create callback
+  # Creates a the inverse of this tie
+  def create_inverse
+    if !_without_inverse &&
+       relation.inverse.present? &&
+       Tie.inverse(self).blank?
+      t = Tie.inverse(self).build
+      t._without_inverse = true
+      t.save!
+    end
+  end
+
+  class << self
+    def Actor_id(a)
+      case a
+      when Integer
+        a
+      when Actor
+        a.id
+      else
+        a.actor.id
+      end
+    end
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,82 @@
+class User < ActiveRecord::Base
+  # Include default devise modules. Others available are:
+  # :token_authenticatable, :confirmable, :lockable, :timeoutable, :validatable
+  devise :database_authenticatable, :registerable,
+         :recoverable, :rememberable, :trackable
+
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :name, :email, :password, :password_confirmation, :remember_me
+
+  validates_presence_of :name, :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
+
+  protected
+  
+  # From devise
+  def password_required?
+    !persisted? || !password.nil? || !password_confirmation.nil?
+  end
+
+  class << self
+    %w( email permalink 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_permalink(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
+  end
+end

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

@@ -0,0 +1,5 @@
+<% if activity.is_root? %>
+  <%= render :partial => "activities/root_activity", :object => activity %>
+<% else %>
+  <%= render :partial => "activities/subactivity", :object => activity %>
+<% end %>

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

@@ -0,0 +1,8 @@
+<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>
+    <li><div class="verb_comment"> · <%= link_to t('activity.to_comment'), "#", :class => "to_comment" %> </div></li>
+    <li><div class="verb_like" id="like_<%= dom_id(activity) %>"> · <%= like_activity(activity)%></div></li>
+    <li><div class="verb_delete"> · <%= link_to t('activity.delete'), activity.direct_object , :confirm => t('activity.confirm_delete'), :method => :delete,  :remote => true %> </div></li>
+  </ul>
+</div>

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

@@ -0,0 +1,52 @@
+//javascript for main activities input
+$("#activities_share_btn").hide();
+title = "<%= t('activity.input') %>";
+$("#input_activities").click(function(){
+  if(this.value == title){
+    this.value="";
+    $("#activities_share_btn").show();
+  }
+});
+$("#input_activities").blur(function(){
+  if(this.value == ""){
+    this.value= title;
+    $("#activities_share_btn").hide();
+  }
+});
+
+//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();
+	return false;
+});
+$(".to_comment").livequery("blur", function(){
+  $(this).parents(".activity_content").find(".input_new_comments").blur();
+	return false;
+});

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

@@ -0,0 +1,13 @@
+<div id="activities_header" class="content_size">
+  <%= form_for Post.new(:text => t('activity.input'),
+                        :_activity_tie_id => current_tie.id),
+                        :remote => true  do |f| %>
+    <%= f.hidden_field :_activity_tie_id %>
+    <%= f.text_field :text, :id => "input_activities", :size => 85 %>
+    <div id="activities_share_btn">
+       <%= image_submit_tag "buttons/btn_security.png" %>
+       <%= image_submit_tag "buttons/btn_share.png" %>
+    </div>
+  <% end -%>
+</div>
+

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

@@ -0,0 +1,44 @@
+<%= div_for root_activity do %>
+  <div class="actor_logo">
+    <%= link_to image_tag(root_activity.sender_subject.logo,
+                          :size => "50x50",
+                          :alt => root_activity.sender_subject.name),
+                 root_activity.sender_subject %>
+  </div>
+
+  <div class="activity_content">
+    <div class="actor_name">
+      <%= link_to(root_activity.sender_subject.name, root_activity.sender_subject) %>
+    </div>
+
+    <div class="activity_objects">
+      <%= render root_activity.activity_objects %>
+    </div>
+
+    <%= render :partial => 'activities/activity_options',
+               :locals => { :activity => root_activity } %>
+
+    <div class="activity_comments" id="comments_<%= dom_id(root_activity) %>">
+      <%= render root_activity.comments %>
+    </div>
+
+    <div class="activity_new_comment">
+       <%= form_for Comment.new(:text => t('comment.input'),
+                                :_activity_tie_id => current_tie.id,
+                                :_activity_parent_id => root_activity.id),
+                    :remote => true do |f| %>
+         <%= f.hidden_field :_activity_tie_id %>
+         <%= f.hidden_field :_activity_parent_id %>
+         <%= f.text_field :text,   :class =>"input_new_comments" %>
+         <div class="activities_comment_btn">
+           <div class="activities_security"></div>
+           <%= image_submit_tag "buttons/btn_share.png" %>
+         </div>
+       <% end %>
+    </div>
+  </div>			
+  <div class="space_comments"></div>
+  <div class="space_activities">
+  <div class="space_sub"></div>
+  </div>
+<% end %>

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

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