social_stream 0.3.6 → 0.4.0

data/app/models/activity_object.rb

@@ -1,3 +1,13 @@
+# 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

data/app/models/activity_object_activity.rb

@@ -1,4 +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/actor.rb

@@ -1,89 +1,106 @@
-# An {Actor} is a social entity. This includes individuals, but also groups, departments, organizations even nations or states.
+# An {Actor} is a social entity. This includes individuals, but also groups, departments,
+# organizations even nations or states.
 #
 # Actors are the nodes of a social network. Two actors are linked by a {Tie}. The
 # type of a {tie} is a {Relation}. Each actor can define and customize their relations.
 #
 # = Actor subtypes
 # An actor subtype is called a {SocialStream::Models::Subject Subject}.
-# {SocialStream} provides two actor subtypes, {User} and {Group}, but the
+# {SocialStream} provides 2 actor subtypes, {User} and {Group}, but the
 # application developer can define as many actor subtypes as required.
 # Actors subtypes are added to +config/initializers/social_stream.rb+
 #
 class Actor < ActiveRecord::Base
   @subtypes_name = :subject
   include SocialStream::Models::Supertype
-
+  
   validates_presence_of :name, :subject_type
-
-  acts_as_url :name, :url_attribute => :permalink
-
+  
+  acts_as_messageable
+  acts_as_url :name, :url_attribute => :slug
+  
   has_attached_file :logo,
                     :styles => { :tie => "30x30>",
                                  :actor => '35x35>',
                                  :profile => '94x94' },
                     :default_url => "/images/:attachment/:style/:subtype_class.png"
-
+  
   has_one :profile, :dependent => :destroy
-
+  
   has_many :sent_ties,
            :class_name => "Tie",
            :foreign_key => 'sender_id',
            :dependent => :destroy
-
+  
   has_many :received_ties,
            :class_name => "Tie",
            :foreign_key => 'receiver_id',
            :dependent => :destroy
-
+  
   has_many :senders,
            :through => :received_ties,
            :uniq => true
-
+  
   has_many :receivers,
            :through => :sent_ties,
            :uniq => true
-
+  
   after_create :initialize_ties
-
+  
   after_create :create_profile
-
+  
   class << self
     # Get actor's id from an object, if possible
     def normalize_id(a)
       case a
-      when Integer
-        a
-      when Array
+        when Array
         a.map{ |e| normalize_id(e) }
-      when Actor
-        a.id
       else
-        a.actor.id
+        Actor.normalize(a).id
+      end
+    end
+    # Get actor from object, if possible
+    def normalize(a)
+      case a
+        when Actor
+        a
+        when Integer
+        Actor.find a
+        when Array
+        a.map{ |e| Actor.normalize(e) }
+      else
+        begin
+          a.actor
+        rescue
+          raise "Unable to normalize actor #{ a.inspect }"        
+        end
       end
     end
   end
-
+  
+  
+  
   # The subject instance for this actor
   def subject
     subtype_instance ||
-      activity_object.try(:object)
+    activity_object.try(:object)
   end
-
+  
   # All the ties sent or received by this actor
   def ties
     Tie.sent_or_received_by(self)
   end
-
+  
   # Relations defined and managed by this actor
   def relations
     Relation.includes(:ties).merge(Tie.sent_by(self))
   end
-
+  
   # A given relation defined and managed by this actor
   def relation(name)
     relations.find_by_name(name)
   end
-
+  
   # All the actors this one has relation with
   #
   # Options:
@@ -95,32 +112,32 @@ class Actor < ActiveRecord::Base
   def actors(options = {})
     subject_types   = Array(options[:subject_type] || self.class.subtypes)
     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 :senders
+      when :senders
       as = as.joins(:sent_ties).merge(Tie.received_by(self))
-    when :receivers
+      when :receivers
       as = as.joins(:received_ties).merge(Tie.sent_by(self))
     else
       raise "actors in both directions is not supported yet"
     end
-
+    
     if options[:include_self].blank?
       as = as.where("actors.id != ?", self.id)
     end
-
+    
     if options[:relations].present?
       as &= Tie.related_by(options[:relations])
     end
-
+    
     as
   end
-
+  
   # All the subject actors that send or receive at least one tie to this actor
   #
   # When passing a block, it will be evaluated for the actors query, allowing to add 
@@ -129,23 +146,23 @@ class Actor < ActiveRecord::Base
   # See actors for options
   def subjects(options = {})
     as = actors(options)
-
+    
     if block_given?
       as = yield(as)
     end
-
+    
     as.map(&:subject)
   end
-
+  
   # This is an scaffold for a recomendations engine
   #
-
+  
   # Make n suggestions
   # TODO: make more
   def suggestions(n)
     n.times.map{ |m| suggestion }
   end
-
+  
   # By now, it returns a tie suggesting a relation from SuggestedRelations
   # to another subject without any current relation
   #
@@ -155,10 +172,10 @@ class Actor < ActiveRecord::Base
   # @return [Tie]
   def suggestion(options = {})
     candidates_types =
-      options[:type].present? ?
-        Array(options[:type]) :
-        self.class.subtypes
-
+    options[:type].present? ?
+    Array(options[:type]) :
+    self.class.subtypes
+    
     candidates_classes = candidates_types.map{ |t| t.to_s.classify.constantize }
     
     # Candidates are all the instance of "type" minus all the subjects
@@ -168,56 +185,67 @@ class Actor < ActiveRecord::Base
       cs -= Array(subject) if subject.is_a?(klass)
       cs
     end
-
+    
     candidate = candidates[rand(candidates.size)]
-
+    
     return nil unless candidate.present?
-
+    
     # Building ties with sent_ties catches them and excludes them from pending ties.
     # An useful side effect for excluding this ones from pending, but can be weird!
     # Maybe we must use:
     # Tie.sent_by(self).build :receiver_id => candidate.actor.id
     sent_ties.build :receiver_id => candidate.actor.id
   end
-
+  
   # Set of ties sent by this actor received by a
   def ties_to(a)
     sent_ties.received_by(a)
   end
-
+  
   # All the ties this actor has with subject that support permission
   def sent_ties_allowing(subject, action, objective)
     return [] if subject.blank?
-
+    
     sent_ties.allowing(subject, action, objective)
   end
 
+  # The ties that allow attaching an activity to them. This method is used for caching
+  def active_ties
+    @active_ties ||= {}
+  end
+
+  # The ties that allow subject creating activities for this actor
+  def active_ties_for(subject)
+    active_ties[subject] ||=
+      sent_ties_allowing(subject, 'create', 'activity')
+  end
+
   def pending_ties
     @pending_ties ||=
-      received_ties.where('ties.sender_id NOT IN (?)', sent_ties.map(&:receiver_id).uniq).map(&:sender_id).uniq.
-        map{ |i| Tie.new :sender => self,
+    received_ties.where('ties.sender_id NOT IN (?)', sent_ties.map(&:receiver_id).uniq).map(&:sender_id).uniq.
+    map{ |i| Tie.new :sender => self,
                          :receiver_id => i }
   end
-
+  
   # The set of activities in the wall of this actor, includes all the activities
   # from the ties the actor has access to
   #
   def home_wall
     Activity.home_wall ties
   end
-
+  
   # The set of activities in the wall profile of this actor, includes the activities
   # from the ties of this actor that can be read by user
   #
   def profile_wall(user)
     # FIXME: show public activities
     return [] if user.blank?
-
+    
     Activity.profile_wall ties.allowing(user, 'read', 'activity')
   end
-
+  
   private
-
+  
   def initialize_ties
     ::SocialStream::Relations.create(subject_type).each do |r|
       sent_ties.create! :receiver => self,
@@ -225,4 +253,3 @@ class Actor < ActiveRecord::Base
     end
   end
 end
-

data/app/models/group.rb

@@ -2,12 +2,18 @@ class Group < ActiveRecord::Base
   attr_accessor :_founder
   attr_accessor :_participants
 
-  def followers
-    subjects(:subject_type => :user, :direction => :senders)
-  end
+  delegate :description, :description=, :to => :profile!
 
   after_create :create_founder
   after_create :create_participants
+
+  def profile!
+    actor!.profile || actor!.build_profile
+  end
+
+  def followers
+    subjects(:subject_type => :user, :direction => :senders)
+  end
   
   def recent_groups
     subjects(:subject_type => :group, :direction => :receivers) do |q|
@@ -21,7 +27,7 @@ class Group < ActiveRecord::Base
   #Creates the ties between the group and the founder
   def create_founder
     founder =
-      Actor.find_by_permalink(_founder) || raise("Cannot create group without founder")
+      Actor.find_by_slug(_founder) || raise("Cannot create group without founder")
 
     sent_ties.create! :receiver => founder,
                       :relation => relations.sort.first

data/app/models/like.rb

@@ -0,0 +1,34 @@
+# Convenience class for managing like activities
+class Like
+  attr_reader :activity
+
+  class << self
+    # Find the children activity of activity_id liked by subject
+    def find(subject, activity_id)
+      find_activity(activity_id).liked_by(subject).first
+    end
+
+    # Like #find but raises error if not found
+    def find!(subject, activity_id)
+      find(subject, activity_id) ||
+        raise(ActiveRecord::RecordNotFound)
+    end
+
+    # Find the activity that is liked
+    def find_activity(id)
+      Activity.find(id) ||
+        raise(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  # Initialize a new like activity
+  def initialize(subject, activity_id)
+    @subject  = subject
+    @activity = self.class.find_activity(activity_id)
+    @like     = @activity.new_like(@subject)
+  end
+
+  def save
+    @like.save
+  end
+end

data/app/models/logo.rb

@@ -0,0 +1,51 @@
+require 'RMagick'
+
+class Logo < ActiveRecord::Base
+ has_attached_file :logo,
+                        :styles => { :tie => "30x30>",
+                                     :actor => '35x35>',
+                                     :profile => '94x94' },
+                        :default_url => "/images/:attachment/:style/:subtype_class.png"
+	before_post_process :process_precrop
+	attr_accessor :crop_x, :crop_y, :crop_w, :crop_h
+	validates_attachment_presence :logo
+
+   def process_precrop
+      logo.errors['precrop'] = "You have to make precrop"
+	
+      images_path = File.join(RAILS_ROOT, "public", "images")
+      tmp_path = FileUtils.mkdir_p(File.join(images_path, "tmp"))
+      
+      resize_image(logo.queued_for_write[:original].path,600,600)
+ 
+      my_file_name = File.basename(logo.queued_for_write[:original].path)
+      FileUtils.cp(logo.queued_for_write[:original].path,tmp_path)
+      temp_file = File.open(logo.queued_for_write[:original].path, "w+")   
+   end
+   
+   def image_dimensions(name)
+   	images_path = File.join(RAILS_ROOT, "public", "images")
+    tmp_path = FileUtils.mkdir_p(File.join(images_path, "tmp"))
+   	file_path = File.join(tmp_path,name)
+   	
+   	img_orig = Magick::Image.read(file_path).first
+   	dimensions = {}
+   	dimensions[:width] =  img_orig.columns
+   	dimensions[:height] = img_orig.rows
+   	dimensions
+   end
+   
+   def resize_image(path,width,height)
+	img_orig = Magick::Image.read(path).first
+   	img_orig = img_orig.resize_to_fit(width, height)
+   	img_orig.write(path)
+   end
+   
+   def make_precrop(path,x,y,width,height)
+     img_orig = Magick::Image.read(path).first
+     crop_args = [x,y,width,height]
+     img_orig = img_orig.crop(*crop_args)
+     img_orig.write(path)
+  end   
+end
+