social_stream-base 0.6.3 → 0.6.5

data/app/models/actor.rb

@@ -56,11 +56,6 @@ class Actor < ActiveRecord::Base
            :uniq => true
 
   has_many :relations
-  has_many :spheres
-
-  has_many :relation_customs,
-           :through => :spheres, 
-           :source  => :customs
 
   scope :alphabetic, order('actors.name')
 
@@ -140,12 +135,31 @@ class Actor < ActiveRecord::Base
     end
   end
   
+  # Returns the email used for Mailboxer
+  def mailboxer_email    
+    return email if email.present?
+    if (group = self.subject).is_a? Group
+      relation = group.relation_customs.sort.first
+      receivers = group.contact_actors(:direction => :sent, :relations => relation)
+      emails = Array.new
+      receivers.each do |receiver|
+        emails << receiver.mailboxer_email
+      end
+      return emails
+    end
+  end
+  
   # The subject instance for this actor
   def subject
     subtype_instance ||
     activity_object.try(:object)
   end
 
+  # All the {Relation relations} defined by this {Actor}
+  def relation_customs
+    relations.where(:type => 'Relation::Custom')
+  end
+
   # A given relation defined and managed by this actor
   def relation_custom(name)
     relation_customs.find_by_name(name)
@@ -161,7 +175,7 @@ class Actor < ActiveRecord::Base
   # Options:
   # * type: Filter by the class of the contacts.
   # * direction: sent or received
-  # * relations: Restrict the relations of considered ties
+  # * relations: Restrict the relations of considered ties. Defaults to {Relation::Custom relations of custom type}
   # * include_self: False by default, don't include this actor as subject even they have ties with themselves.
   #
   def contact_actors(options = {})
@@ -169,15 +183,15 @@ class Actor < ActiveRecord::Base
     subject_classes = subject_types.map{ |s| s.to_s.classify }
     
     as = Actor.select("DISTINCT actors.*").
-    where('actors.subject_type' => subject_classes).
-    includes(subject_types)
+               where('actors.subject_type' => subject_classes).
+               includes(subject_types)
     
     
     case options[:direction]
       when :sent
-        as = as.contacted_from(self)
+        as = as.joins(:received_ties => :relation).merge(Contact.sent_by(self))
       when :received
-        as = as.contacted_to(self)
+        as = as.joins(:sent_ties => :relation).merge(Contact.received_by(self))
     else
       raise "contact actors in both directions are not supported yet"
     end
@@ -187,7 +201,9 @@ class Actor < ActiveRecord::Base
     end
     
     if options[:relations].present?
-      as = as.joins(:ties).merge(Tie.related_by(options[:relations]))
+      as = as.merge(Tie.related_by(options[:relations]))
+    else
+      as = as.merge(Relation.where(:type => 'Relation::Custom'))
     end
     
     as
@@ -241,7 +257,7 @@ class Actor < ActiveRecord::Base
     # Candidates are all the instance of "type" minus all the subjects
     # that are receiving any tie from this actor
     candidates = candidates_classes.inject([]) do |cs, klass|
-      cs += klass.all - contact_subjects(:type => klass.to_s.underscore, :direction => :sent)
+      cs += klass.all - contact_subjects(:type => klass.to_s.underscore, :direction => :sent, :relations => relations.to_a)
       cs -= Array(subject) if subject.is_a?(klass)
       cs
     end
@@ -250,7 +266,7 @@ class Actor < ActiveRecord::Base
     
     return nil unless candidate.present?
     
-    Contact.new :sender => self, :receiver => candidate.actor
+    contact_to!(candidate)
   end
   
   # Set of ties sent by this actor received by subject
@@ -279,30 +295,15 @@ class Actor < ActiveRecord::Base
         any?
   end
 
-  # The relations that allow attaching an activity to them. This method is used for caching
-  def active_relations
-    @active_relations ||= { :sender => {}, :receiver => {} }
-  end
-
   # An {Activity} can be shared with multiple {audicences Audience}, which corresponds to a {Relation}.
   #
   # This method returns all the {relations Relation} that this actor can use to broadcast an Activity
   #
-  # Options:
-  # from:: limit the relations to one side, from the :sender or the :receiver of the activity
   #
   def activity_relations(subject, options = {})
     return relations if Actor.normalize(subject) == self
 
-    case options[:from]
-    when :sender
-      sender_activity_relations(subject)
-    when :receiver
-      receiver_activity_relations(subject)
-    else
-      sender_activity_relations(subject) +
-        receiver_activity_relations(subject)
-    end
+    Array.new
   end
 
   # Are there any activity_relations present?
@@ -310,48 +311,6 @@ class Actor < ActiveRecord::Base
     activity_relations(*args).any?
   end
 
-  # Relations from this actor that can be read by subject
-  def sender_activity_relations(subject)
-    active_relations[:sender][subject] ||=
-      Relation.allow(subject, 'read', 'activity', :owner => self)
-  end
-
-  def receiver_activity_relations(subject)
-    active_relations[:receiver][subject] ||=
-      Relation.allow(self, 'create', 'activity', :owner => subject)
-  end
-
-  # Builds a hash of options their spheres as keys
-  def grouped_activity_relations(subject)
-    rels = activity_relations(subject)
-
-    spheres =
-      rels.map{ |r| r.respond_to?(:sphere) ? r.sphere : I18n.t('relation_public.name') }.uniq
-
-    spheres.sort!{ |x, y|
-      case x
-      when Sphere
-        case y
-        when Sphere
-          x.id <=> y.id
-        else
-          -1
-        end
-      else
-        1
-      end
-    }
-
-    spheres.map{ |s|
-      case s
-      when Sphere
-        [ s.name, rels.select{ |r| r.respond_to?(:sphere) && r.sphere == s }.sort.map{ |u| [ u.name, u.id ] } ]
-      else
-        [ s, rels.select{ |r| r.is_a?(Relation::Public) }.map{ |u| [ u.name, u.id ] } ]
-      end
-    }
-  end
-
   # Is this {Actor} allowed to create a comment on activity?
   #
   # We are allowing comments from everyone signed in by now

data/app/models/contact.rb

@@ -100,6 +100,21 @@ class Contact < ActiveRecord::Base
     association(:relations).ids_writer(ids)
   end
 
+  # Is this {Contact} +new+ or +edit+ for {SocialStream::Models::Subject subject} ?
+  #
+  # action is +new+ when, despite of being created, it has not {Tie ties} or it has a {Tie} with a
+  # {Relation::Public public relation}. 
+  #
+  # The contact's action is +edit+ when it has any {Tie} with a {Relation::Custom custom relation}
+  #
+  def action
+    if ties_count > 0 && relations.where(:type => 'Relation::Custom').any?
+      'edit'
+    else
+      'new'
+    end
+  end
+
   private
 
   def remove_follower(ids)

data/app/models/group.rb

@@ -23,9 +23,7 @@ class Group < ActiveRecord::Base
         merge(Contact.recent)
     end
   end
- 
-  private
-
+  
   # Creates the ties between the group and the founder
   def create_founder
     founder =

data/app/models/permission.rb

@@ -1,5 +1,5 @@
-# SocialStream provides a sophisticated and powerful system of permissions based on the {Relation relations}
-# of the social network.
+# SocialStream provides a system of permissions based on the {Relation relations}
+# of the social network as roles.
 #
 # = Permissions and Relations
 #
@@ -13,9 +13,9 @@
 #
 # = Permissions description
 #
-# Permissions are composed by *action*, *objective* and *function*. Action and objective
+# Permissions are composed by *action* and *object*. Action and object
 # are typical in content management systems, e.g. <tt>create activity</tt>,
-# <tt>update tie</tt>, <tt>read post</tt>. *function* is a new parameter for social networks
+# <tt>update tie</tt>, <tt>read post</tt>.
 #
 # == Actions
 #
@@ -32,33 +32,8 @@
 #
 # +activity+:: all the objects in a wall: posts, comments
 #
-# Other objectives currently not implemented could be +tie+, +post+, +comment+ or +message+
+# Other objects currently not implemented could be +tie+, +post+, +comment+ or +message+
 #
-# == Functions
-#
-# Function is a novel feature. It supports applying the permission to other related relations and ties.
-# It is required because the set of ties changes while {SocialStream::Models::Subject subjects } build their network. 
-# Besides {SocialStream::Models::Subject subjects} can describe and
-# customize their own relations and permissions.
-#
-# Available functions are:
-#
-# +same_level+:: the permission applies to all the objects in same relation
-#
-#               Example: the _friend_ relation has the permission
-#               <tt>read tie same_level</tt>. If _Alice_ has a _friend_ tie with
-#               _Bob_, she is granting him access to read all the contacts of type _friend_
-##
-# +same_and_lower_levels+:: apply the permission to all the related objects attached to a relation weaker
-#               or equal than this.#
-#
-#               Example: if the _member_ relation of a group has the permission
-#               <tt>create activity same_and_lower_levels</tt>, its members
-#               can also create activities attached to the weaker relations of
-#               _acquaintance_ and _public_.
-#               This means than a group _member_ can create activities at different
-#               levels of the sphere, and therefore, with different levels of
-#               access.
 #
 class Permission < ActiveRecord::Base
   has_many :relation_permissions, :dependent => :destroy
@@ -68,51 +43,13 @@ class Permission < ActiveRecord::Base
     scope p, where(:action => p) # scope :represent, where(:action => 'represent')
   end
 
-  RelationConditions = {
-    'same_level' =>
-        "relations.id = relations_as.id",
-    'same_and_lower_levels' =>
-      "(relations.id = relations_as.id OR relations.ancestry = relations_as.id || '' OR relations.ancestry = (relations_as.ancestry || '/' || relations_as.id) OR relations.ancestry LIKE (relations_as.id || '/%') OR relations.ancestry LIKE (relations_as.ancestry || '/' || relations_as.id || '/%')) OR (relations.actor_id = relations_as.actor_id AND relations.type = 'Relation::Public')"
-  }
-
-  class << self
-    # Builds SQL conditions based on {RelationConditions}
-    def relation_conditions
-      RelationConditions.inject([]){ |result, pc|
-        result <<
-          "(#{ pc.last }) AND #{ sanitize_sql('permissions_as.function' => pc.first) }"
-      }.join(" OR ")
-    end
-  end
-
   # An explanation of the permissions. Type can be brief or detailed.
-  # If detailed, description includes details about the relation
+  # If detailed, description includes more information about the relation
   def description(type, relation = nil)
-    options = ( relation.present? ? description_options(relation) : {} )
+    options = {}
+    options[:relation] = relation.name if relation.present?
 
-    I18n.t "permission.description.#{ type }.#{ action }.#{ object || "nil" }.#{ function || "nil" }",
+    I18n.t "permission.description.#{ type }.#{ action }.#{ object || "nil" }",
            options
   end
-
-  private
-
-  def description_options(relation)
-    { 
-      :sphere => relation.sphere.name,
-      :public => I18n.t('relation_public.name')
-    }.tap do |h|
-      case function
-      when NilClass, "same_level"
-        h[:relation] = relation.name
-      when "same_and_lower_levels"
-        h[:relations] = relation.
-                        weaker_or_equal.
-                        sort.
-                        map(&:name).
-                        join(", ")
-
-      end
-    end
-
-  end
 end

data/app/models/profile.rb

@@ -17,18 +17,23 @@ class Profile < ActiveRecord::Base
   
   validate :validate_birthday
   
-  def birthday=(value)    
+  def birthday=(value)
+    
+    puts "He entrado en el metodo birthday con un :" + value.class.to_s 
+          
     if value.blank?
       @birthday_formatted_invalid = false    
       super value
     else
       begin
-        super Date.parse(value)
+        #super Date.parse(value)
+        super value
         @birthday_formatted_invalid = false
       rescue 
         @birthday_formatted_invalid = true
       end
     end
+
   end
   
   def age

data/app/models/relation/custom.rb

@@ -13,16 +13,10 @@ class Relation::Custom < Relation
   inspect
   has_ancestry
 
-  attr_protected :actor_id
-
-  belongs_to :sphere
   belongs_to :actor
 
-  validates_presence_of :name, :sphere_id, :actor_id
-  validates_uniqueness_of :name, :scope => :sphere_id
-
-  before_validation :assign_parent, :on => :create
-  before_validation :assign_actor,  :on => :create
+  validates_presence_of :name, :actor_id
+  validates_uniqueness_of :name, :scope => :actor_id
 
   class << self
     # Relations configuration
@@ -40,18 +34,15 @@ class Relation::Custom < Relation
       rels = {}
 
       cfg_rels.each_pair do |name, cfg_rel|
-        raise("Must associatiate relation #{ cfg_rel['name'] } to a sphere") if cfg_rel['sphere'].blank?
-        sphere = actor.spheres.find_or_create_by_name(cfg_rel['sphere'])
-
         rels[name] =
-          create! :sphere        => sphere,
-                  :receiver_type => cfg_rel['receiver_type'],
-                  :name =>          cfg_rel['name']
+          create! :actor =>         actor,
+                  :name  =>         cfg_rel['name'],
+                  :receiver_type => cfg_rel['receiver_type']
 
         if (ps = cfg_rel['permissions']).present?
           ps.each do |p| 
             rels[name].permissions << 
-              Permission.find_or_create_by_action_and_object_and_function(*p)
+              Permission.find_or_create_by_action_and_object(*p)
           end 
         end
       end
@@ -103,22 +94,4 @@ class Relation::Custom < Relation
   def stronger_or_equal
     path
   end
-
-  private
-
-  # Before create callback
-  #
-  # Assign the last relation as parent if there are other custom relations in the sphere
-  def assign_parent
-    return if parent.present? || sphere.customs.blank?
-
-    self.parent = sphere.customs.sort.last
-  end
-
-  # Before create callback
-  #
-  # Assign the sphere's actor
-  def assign_actor
-    self.actor = sphere.actor
-  end
 end

data/app/models/relation.rb

@@ -30,6 +30,7 @@ class Relation < ActiveRecord::Base
   has_many :permissions, :through => :relation_permissions
 
   has_many :ties, :dependent => :destroy
+  has_many :contacts, :through => :ties
 
   scope :mode, lambda { |st, rt|
     where(:sender_type => st, :receiver_type => rt)
@@ -57,7 +58,7 @@ class Relation < ActiveRecord::Base
       when Array
         r.map{ |e| Relation.normalize(e, options) }
       else
-        raise "Unable to normalize relation #{ r.inspect }"
+        raise "Unable to normalize relation #{ r.class }: #{ r.inspect }"
       end
     end
 
@@ -76,59 +77,34 @@ class Relation < ActiveRecord::Base
     #
     # Options:
     #   in:: Limit possible relations to a set
-    #   owner:: The owner of the relations
     #   public_relations:: include also {Relation::Public} whose activities can always be read
     def allow(subject, action, object, options = {})
-      # The case when the owner == subject is special,
-      # all the permissions are granted to the owner of the relations
-      if options[:owner].present? && Actor.normalize(options[:owner]) == Actor.normalize(subject)
-        rels = subject.relations
+      q = 
+        select("DISTINCT relations.*").
+        joins(:contacts).
+        joins(:permissions)
 
-        if options[:in].present?
-          rels = rels & options[:in]
-        end
-
-        rels
-      end
-
-      # Relation conditions
-      # Some relations can have permissions that grant permissions to other relations
-      # through Relation#function
-      conds = Permission.relation_conditions
-
-      # Permission conditions
-      # Set the permission conditions
-      conds = "( #{ conds } ) AND #{ sanitize_sql('permissions_as.action' => action) } AND #{ sanitize_sql('permissions_as.object' => object) }"
+      conds =
+        Permission.arel_table[:action].eq(action).and(Permission.arel_table[:object].eq(object))
 
       # Relation::Public permissions cannot be customized yet
       if action == 'read' && object == 'activity' && (options[:public].nil? || options[:public])
-        conds =
-          "( #{ conds } ) OR #{ sanitize_sql('relations.type' => 'Relation::Public') }" 
-      end
-
-      # subject conditions
-      #
-      # Relation permissions are granted to the contact receiver.
-      # However, relation owners have all the permissions
-      conds = "( ( #{ conds } ) AND #{ sanitize_sql('contacts_as.receiver_id' => Actor.normalize_id(subject)) } ) OR #{ sanitize_sql('relations.actor_id' => Actor.normalize_id(subject)) }"
-
-      # Add owner condition
-      if options[:owner].present?
-        conds = "( #{ conds } ) AND #{ sanitize_sql('relations.actor_id' => Actor.normalize_id(options[:owner])) }"
+        conds = conds.or(Relation.arel_table[:type].eq('Relation::Public'))
       end
 
       # Add in condition
       if options[:in].present?
-        conds = "( #{ conds } ) AND #{ sanitize_sql('relations.id' => Relation.normalize_id(Array(options[:in]))) }"
+        conds = conds.and(Relation.arel_table[:id].in(Relation.normalize_id(Array(options[:in]))))
       end
 
-      select("DISTINCT relations.*").
-        from("relations, contacts AS contacts_as INNER JOIN ties AS ties_as ON contacts_as.id = ties_as.contact_id INNER JOIN relations AS relations_as ON relations_as.id = ties_as.relation_id INNER JOIN relation_permissions AS relation_permissions_as ON relations_as.id = relation_permissions_as.relation_id INNER JOIN permissions AS permissions_as ON permissions_as.id = relation_permissions_as.permission_id").
-        where(conds)
+      # subject conditions
+      conds = conds.and(Contact.arel_table[:receiver_id].eq(Actor.normalize_id(subject)))
+
+      q.where(conds)
     end
 
     def allow?(*args)
-      allow(*args).any?
+      allow(*args).to_a.any?
     end
   end