social_stream-base 2.1.0 → 2.2.0

data/app/controllers/groups_controller.rb

@@ -1,12 +1,9 @@
 class GroupsController < ApplicationController
   include SocialStream::Controllers::Subjects
+  include SocialStream::Controllers::Authorship
 
   before_filter :authenticate_user!, :except => [ :index, :show ]
 
-  # Set group founder to current_subject
-  # Must do before authorization
-  before_filter :set_founder, :only => [ :new, :create ]
-
   load_and_authorize_resource
 
   respond_to :html, :js
@@ -18,7 +15,7 @@ class GroupsController < ApplicationController
   def create
     create! do |success, failure|
       success.html {
-        self.current_subject = @group
+        self.current_subject = resource
         redirect_to :home
       }
     end
@@ -32,20 +29,4 @@ class GroupsController < ApplicationController
       }
     end
   end
-
-  protected
-
-  # Overwrite resource method to support slug
-  # See InheritedResources::BaseHelpers#resource
-  def resource
-    @group ||= end_of_association_chain.find_by_slug!(params[:id])
-  end
-
-  private
-
-  def set_founder
-    params[:group]                  ||= {}
-    params[:group][:author_id]      ||= current_subject.try(:actor_id)
-    params[:group][:user_author_id] ||= current_user.try(:actor_id)
-  end
 end

data/app/controllers/profiles_controller.rb

@@ -13,6 +13,10 @@ class ProfilesController < ApplicationController
     end
   end
 
+  def edit
+    current_profile
+  end
+
   def update
     current_profile.update_attributes profile_params
 

data/app/controllers/settings_controller.rb

@@ -1,7 +1,7 @@
 class SettingsController < ApplicationController
-    
+
   before_filter :authenticate_user!
-  
+
   def index
   end
 
@@ -20,6 +20,16 @@ class SettingsController < ApplicationController
           current_subject.notify_by_email = false if notify_by_email.eql? "never"
           current_subject.notify_by_email = true if notify_by_email.eql? "always"
         end
+
+        # Custom notification settings
+        if params[:notification_settings].present?
+          notification_settings = {}
+          params[:notification_settings].each_pair do |key, setting|
+            notification_settings[key.to_sym] = false if setting.eql? "never"
+            notification_settings[key.to_sym] = true if setting.eql? "always"
+          end
+          current_subject.update_attribute(:notification_settings, notification_settings)
+        end
       end
 
       #Updating language

data/app/controllers/users_controller.rb

@@ -21,12 +21,4 @@ class UsersController < ApplicationController
   def new; end; def create; end
   # Not supported yet
   def destroy; end
-
-  protected
-
-  # Overwrite resource method to support slug
-  # See InheritedResources::BaseHelpers#resource
-  def resource
-    @user ||= end_of_association_chain.find_by_slug!(params[:id])
-  end
 end

data/app/helpers/contacts_helper.rb

@@ -43,4 +43,12 @@ module ContactsHelper
   def current_contact_section? section
     params[:type] == section.to_s
   end
+
+  def contact_select_options options
+    if !options.empty? && options.first.respond_to?(:last) && Array === options.first.last
+      grouped_options_for_select(options)
+    else
+      options_for_select(options)
+    end
+  end
 end

data/app/models/activity.rb

@@ -260,12 +260,25 @@ class Activity < ActiveRecord::Base
     return true unless notificable?
     #Avaible verbs: follow, like, make-friend, post, update, join
 
-    if direct_object.is_a? Comment
-      participants.each do |p|
-        p.notify(notification_subject, "Youre not supposed to see this", self) unless p == sender
-      end
-    elsif ['like','follow','make-friend','post','update', 'join'].include? verb and !reflexive?
-      receiver.notify(notification_subject, "Youre not supposed to see this", self)
+    case
+      when direct_object.is_a?(Comment)
+        participants.each do |p|
+          send_mail = p.subject.notification_settings[:someone_comments_on_my_post]
+          p.notify(notification_subject, "Youre not supposed to see this", self, true, nil, send_mail) unless p == sender
+        end
+      when reflexive?
+        return true
+      when ['like'].include?(verb)
+        send_mail = receiver.subject.notification_settings[:someone_likes_my_post]
+        receiver.notify(notification_subject, "Youre not supposed to see this", self, true, nil, send_mail)
+      when ['follow'].include?(verb)
+        send_mail = receiver.subject.notification_settings[:someone_adds_me_as_a_contact]
+        receiver.notify(notification_subject, "Youre not supposed to see this", self, true, nil, send_mail)
+      when ['make-friend'].include?(verb)
+        send_mail = receiver.subject.notification_settings[:someone_confirms_my_contact_request]
+        receiver.notify(notification_subject, "Youre not supposed to see this", self, true, nil, send_mail)
+      when ['post', 'update', 'join'].include?(verb)
+        receiver.notify(notification_subject, "Youre not supposed to see this", self)
     end
     true
   end

data/app/models/actor.rb

@@ -28,7 +28,9 @@ class Actor < ActiveRecord::Base
   acts_as_messageable
 
   acts_as_url :name, :url_attribute => :slug
-  
+
+  serialize :notification_settings
+
   has_one :profile,
           dependent: :destroy,
           inverse_of: :actor
@@ -132,6 +134,12 @@ class Actor < ActiveRecord::Base
     joins(:received_contacts).merge(Contact.active.sent_by(a))
   }
 
+  scope :not_contacted_from, lambda { |a|
+    if a.present?
+      where(arel_table[:id].not_in(a.sent_active_contact_ids + [a.id]))
+    end
+  }
+
   scope :followed, joins(:activity_object).merge(ActivityObject.followed)
 
   scope :followed_by, lambda { |a|
@@ -143,7 +151,7 @@ class Actor < ActiveRecord::Base
 
   scope :subject_type, lambda { |t|
     if t.present?
-      where(subject_type: t.classify)
+      where(subject_type: t.split(',').map(&:classify))
     end
   }
 
@@ -217,15 +225,30 @@ class Actor < ActiveRecord::Base
   # They usually include {Relation::Custom} but may also include other system-defined
   # relations that are not editable but appear in add contact buttons
   def relations_list
-    Relation.extra_list(subject) + relation_customs
+    Relation.system_list(subject) + relation_customs
   end
 
   # The relations offered in the "Add contact" button when subjects
   # add new contacts
-  def relations_for_button
+  def relations_for_select
     relations_list
   end
 
+  # Return an object of choices suitable for the contact add button or modal
+  def options_for_contact_select
+    relations_for_select.map{ |r| [ r.name, r.id ] }
+  end
+
+  # Options for contact select are simple
+  def options_for_contact_select_simple?
+    relations_list.count == 1
+  end
+
+  # Returns the type for contact select, :simple or :multiple
+  def options_for_contact_select_type
+    options_for_contact_select_simple? ? :simple : :multiple
+  end
+
   # All the {Actor Actors} this one has ties with:
   # 
   #   actor.contact_actors #=> array of actors that sent and receive ties from actor
@@ -293,7 +316,7 @@ class Actor < ActiveRecord::Base
     if options[:relations].present?
       as = as.merge(Tie.related_by(options[:relations]))
     else
-      as = as.merge(Relation.where(:type => ['Relation::Custom', 'Relation::Public']))
+      as = as.merge(Relation.positive)
     end
     
     as
@@ -328,7 +351,7 @@ class Actor < ActiveRecord::Base
   # Return a contact to subject. Create it if it does not exist
   def contact_to!(subject)
     contact_to(subject) ||
-      sent_contacts.create!(:receiver => Actor.normalize(subject))
+      sent_contacts.create!(receiver_id: Actor.normalize_id(subject))
   end
 
   # The {Contact} of this {Actor} to self (totally close!)
@@ -434,11 +457,21 @@ class Actor < ActiveRecord::Base
 
   # The default {Relation Relations} for sharing an {Activity} owned
   # by this {Actor}
+  #
+  # Activities are shared with all the contacts by default.
+  #
+  # You can change this behaviour with a decorator, overwriting this method.
+  # For example, if you want the activities shared publicly by default, create
+  # a decorator in app/decorators/actor_decorator.rb with
+  #   Actor.class_eval do
+  #     def activity_relations
+  #       [ Relation::Public.instance ]
+  #     end
+  #   end
+  #
   def activity_relations
-    SocialStream.relation_model == :custom ?
-      relations.
-        allowing('read', 'activity') :
-      [ Relation::Public.instance ]
+    relations.
+      allowing('read', 'activity')
   end
 
   # The ids of the default {Relation Relations} for sharing an {Activity}
@@ -516,7 +549,12 @@ class Actor < ActiveRecord::Base
       }
     }
   end
-  
+
+  def notification_settings
+    self.update_attribute(:notification_settings, SocialStream.default_notification_settings) unless super
+    super
+  end
+
   private
   
   # After create callback

data/app/models/contact.rb

@@ -49,10 +49,10 @@ class Contact < ActiveRecord::Base
   }
 
   scope :in_direction_with, lambda { |subject, d = 'sent'|
-    if d == 'sent'
-      sent_by(subject).joins(:receiver)
-    else
+    if d == 'received'
       received_by(subject).joins(:sender)
+    else
+      sent_by(subject).joins(:receiver)
     end
   }
 
@@ -180,9 +180,16 @@ class Contact < ActiveRecord::Base
     end
   end
 
-  # Return an array of options suitable for the contact add button
+  # Return an object of choices suitable for the contact add button
+  #
   def options_for_select
-    sender.relations_for_button.map{ |r| [ r.name, r.id ] }
+    sender.options_for_contact_select
+  end
+
+  # Options for select are simple or multiple
+  #
+  def options_for_select_type
+    sender.options_for_contact_select_type
   end
 
   private

data/app/models/group.rb

@@ -6,7 +6,7 @@
 class Group < ActiveRecord::Base
   include SocialStream::Models::Subject
 
-  attr_accessor :_participants
+  attr_accessor :owners
 
   delegate :description, :description=, :to => :profile!
 
@@ -19,14 +19,14 @@ class Group < ActiveRecord::Base
   private
 
   # Creates ties from founder to the group, based on _relation_ids,
-  # and ties from the group to founder and participants.
+  # and ties from the group to founder and owners.
   def create_ties
-    create_ties_from_founder
-    create_ties_to_participants
+    create_ties_from_author
+    create_ties_to_owners
   end
 
   # Creates the ties from the founder to the group
-  def create_ties_from_founder
+  def create_ties_from_author
 =begin
     # FIXME: need to define a proper relation for this case. Maybe a system defined relation
     author.sent_contacts.create! :receiver_id  => actor_id,
@@ -39,18 +39,20 @@ class Group < ActiveRecord::Base
 =end
   end
   
-  # Creates the ties from the group to the participants
-  def create_ties_to_participants
-    @_participants ||= ""
+  # Creates the ties from the group to the owners added in the group creation form
+  #
+  # The system-defined Relation::Owner is used for the ties
+  def create_ties_to_owners
+    @owners ||= ""
 
-    participant_ids = ([ author_id, user_author_id ] | @_participants.split(',').map(&:to_i)).uniq
+    owner_ids = ([ author_id, user_author_id ] | @owners.split(',').map(&:to_i)).uniq
 
-    participant_ids.each do |a|
+    owner_ids.each do |a|
       c =
         sent_contacts.create! :receiver_id  => a,
                               :user_author  => user_author
       
-      c.relation_ids = Array.wrap(relation_customs.sort.first.id)
+      c.relation_ids = Array.wrap(::Relation::Owner.instance.id)
     end
   end
 end

data/app/models/permission.rb

@@ -44,6 +44,36 @@ class Permission < ActiveRecord::Base
   end
 
   class << self
+    # Obtains the available permissions for subject, as they are configured
+    # in config.available_permissions entry in config/initializers/social_stream.rb
+    #
+    # It takes STI into account, so it will try to load the permissions of the base_class
+    # if the class is not found
+    def available(subject)
+      class_name = subject.class.to_s.underscore
+      base_class_name = subject.class.base_class.to_s.underscore
+
+      candidates = [ class_name, class_name.to_sym ]
+
+      if class_name != base_class_name
+        candidates += [ base_class_name, base_class_name.to_sym ]
+      end
+
+      list = nil
+
+      candidates.each do |n|
+        list = SocialStream.available_permissions[n]
+
+        break if list.present?
+      end
+
+      if list.blank?
+        raise "You need to configure SocialStream.available_permissions[:#{ class_name }] in config/initializers/social_stream.rb"
+      end
+
+      instances list
+    end
+
     # Finds or creates in the database the instances of the permissions described in
     # {ary} by arrays of [ action, object ]
     def instances ary

data/app/models/relation.rb

@@ -41,7 +41,7 @@
 # It sets the {Audience} that has access to it, and the {Permission Permissions} that rule that access.
 #
 class Relation < ActiveRecord::Base
-  Positive = %w{ custom public follow }
+  Positive = %w{ custom public follow owner }
   Negative = %w{ reject }
 
   has_many :relation_permissions, :dependent => :destroy
@@ -152,7 +152,7 @@ class Relation < ActiveRecord::Base
     def ids_shared_with(subject)
       ids = [Relation::Public.instance.id]
 
-      if SocialStream.relation_model == :custom && subject.present?
+      if subject.present?
         # Subject own defined custom relations
         ids += subject.relation_ids
         # From Ties sent by other subject
@@ -168,11 +168,14 @@ class Relation < ActiveRecord::Base
 
     # Default extra relations that are displayed in {Actor}'s relation list,
     # typically in /relation/customs
-    def extra_list subject
-      l = SocialStream.list_relations[subject.class.to_s.underscore]
-      return [] if l.blank?
-
-      l.map{ |r| "Relation::#{ r.to_s.classify }".constantize.instance }
+    def system_list subject
+      name = subject.class.to_s.underscore
+      list = SocialStream.system_relations[name] ||
+        SocialStream.system_relations[name.to_sym]
+      
+      return [] if list.blank?
+
+      list.map{ |r| "Relation::#{ r.to_s.classify }".constantize.instance }
     end
   end
 
@@ -181,6 +184,13 @@ class Relation < ActiveRecord::Base
     Relation.mode(sender_type, receiver_type)
   end
 
+  # Compare two relations
+  def <=> rel
+    return -1 if rel.is_a?(Public)
+
+    permissions.count <=> rel.permissions.count
+  end
+
   # Is this {Relation} a Positive one?
   def positive?
     self.class.positive_names.include?(self.class.to_s)

data/app/models/relation/custom.rb

@@ -2,7 +2,7 @@
 # of relations is created for him. Afterwards, the {SocialStream::Models::Subject subject}
 # can customize them and adapt them to his own preferences.
 #
-# Default relations are defined at config/relations.yml
+# Default relations are defined at config/initializers/social_stream.rb
 #
 class Relation::Custom < Relation
   # This is weird. We must call #inspect before has_ancestry for Relation::Custom
@@ -57,11 +57,6 @@ class Relation::Custom < Relation
 
       rels.values
     end
-
-    # A relation in the top of a strength hierarchy
-    def strongest
-      roots
-    end
   end
 
   # The subject who defined of this relation
@@ -69,41 +64,8 @@ class Relation::Custom < Relation
     actor.subject
   end
 
-  # Compare two relations
-  def <=> rel
-    return -1 if rel.is_a?(Public)
-
-    if ancestor_ids.include?(rel.id)
-      1
-    elsif rel.ancestor_ids.include?(id)
-      -1
-    else
-      0
-    end
-  end
-
-  # Other relations below in the same hierarchy that this relation
-  def weaker
-    descendants
-  end
-
-  # Relations below or at the same level of this relation
-  def weaker_or_equal
-    subtree
-  end
-
-  # Other relations above in the same hierarchy that this relation
-  def stronger
-    ancestors
-  end
-
-  # Relations above or at the same level of this relation
-  def stronger_or_equal
-    path
-  end
-
   def available_permissions
-    Permission.instances SocialStream.available_permissions[subject.class.to_s.underscore]
+    Permission.available(subject)
   end
 
   private