socializer 0.1.13

data/app/models/socializer/activity.rb

@@ -0,0 +1,162 @@
+module Socializer
+  class Activity < ActiveRecord::Base
+    include Socializer::ObjectTypeBase
+
+    default_scope { order(created_at: :desc) }
+
+    attr_accessible :verb, :circles, :actor_id, :activity_object_id, :target_id
+
+    belongs_to :parent,             class_name: 'Activity',       foreign_key: 'target_id'
+    belongs_to :activitable_actor,  class_name: 'ActivityObject', foreign_key: 'actor_id'
+    belongs_to :activitable_object, class_name: 'ActivityObject', foreign_key: 'activity_object_id'
+    belongs_to :activitable_target, class_name: 'ActivityObject', foreign_key: 'target_id'
+    belongs_to :verb, inverse_of: :activities
+
+    has_one  :activity_field, inverse_of: :activity
+    has_many :audiences # , dependent: :destroy
+    has_many :activity_objects, through: :audiences
+    has_many :children, class_name: 'Activity', foreign_key: 'target_id', dependent: :destroy
+    has_many :notifications
+
+    validates :verb, presence: true
+
+    def comments
+      @comments ||= children.joins(:activitable_object).where { activitable_object.activitable_type.eq('Socializer::Comment') }
+    end
+
+    def actor
+      @actor ||= activitable_actor.activitable
+    end
+
+    def object
+      @object ||= activitable_object.activitable
+    end
+
+    def target
+      @target ||= activitable_target.activitable
+    end
+
+    # Selects the activites that either the person made, that is public from a person in
+    # one of his circle, or that is shared to one of the circles he is part of.
+    #
+    # * <tt>options[:provider]</tt>  - <tt>nil</tt>, <tt>activities</tt>, <tt>people</tt>, <tt>circles</tt>, <tt>groups</tt>
+    # * <tt>options[:actor_id]</tt>  - unique identifier of the previously typed provider
+    # * <tt>options[:viewer_id]</tt> - who wants to see the activity stream
+    #
+    #   Activity.stream(provider: nil, actor_id: current_user.id, viewer_id: current_user.id)
+    def self.stream(options = {})
+      options.assert_valid_keys(:provider, :actor_id, :viewer_id)
+
+      provider  = options.delete(:provider)
+      actor_uid = options.delete(:actor_id)
+      viewer_id = options.delete(:viewer_id)
+
+      viewer_id = Person.find(viewer_id).guid
+
+      query = build_query(viewer_id)
+
+      case provider
+      when nil
+        # this is your dashboard. display everything about people in circles and yourself.
+        query.uniq
+      when 'activities'
+        # we only want to display a single activity. make sure the viewer is allowed to do so.
+        activity_id = actor_uid
+        query.where { id.eq(activity_id) }.uniq
+      when 'people'
+        # this is a user profile. display everything about him that you are allowed to see
+        person_id = Person.find(actor_uid).guid
+        query.where { actor_id.eq(person_id) }.uniq
+      when 'circles'
+        # FIXME: Should display notes even if circle has no members and the owner is viewing it.
+        #        Notes still don't show after adding people to the circles.
+
+        circles_sql  = Circle.select { id }.where { (id.eq actor_uid) & (author_id.eq viewer_id) }
+        followed_sql = Tie.select { contact_id }.where { circle_id.in(circles_sql) }
+
+        query.where { actor_id.in(followed_sql) }.uniq
+      when 'groups'
+        # this is a group. display everything that was posted to this group as audience
+        group_id = Group.find(actor_uid).guid
+        # query.where(audiences: {activity_object_id: group_id}).uniq
+        query.where { audiences.activity_object_id.eq(group_id) }.uniq
+      else
+        fail 'Unknown stream provider.'
+      end
+    end
+
+    private
+
+    def self.build_query(viewer_id)
+      fail 'viewer_id cannot be nil.' if viewer_id.nil?
+
+      # for an activity to be interesting, it must correspond to one of these verbs
+      verbs_of_interest = %w(post share)
+      verbs_of_interest = Verb.where { name.in(verbs_of_interest) }
+
+      # privacy_levels
+      privacy_public  = Audience.privacy_level.find_value(:public).value
+      privacy_circles = Audience.privacy_level.find_value(:circles).value
+      privacy_limited = Audience.privacy_level.find_value(:limited).value
+
+      query = joins { audiences }.where { verb_id.in(verbs_of_interest) }.where { target_id.eq(nil) }
+
+      query.where { (audiences.privacy_level == privacy_public) |
+        ((audiences.privacy_level == privacy_circles) & `#{viewer_id}`.in(my { build_circles_subquery })) |
+        ((audiences.privacy_level == privacy_limited) & (
+          `#{viewer_id}`.in(my { build_limited_circle_subquery(viewer_id) }) |
+          audiences.activity_object_id.in(my { build_limited_group_subquery(viewer_id) }) |
+          audiences.activity_object_id.in(my { build_limited_viewer_subquery(viewer_id) })
+        )) |
+        (actor_id == viewer_id) }
+    end
+
+    # Audience : CIRCLES
+    # Ensure the audience is CIRCLES and then make sure that the viewer is in those circles
+    def self.build_circles_subquery
+      # TODO: Convert this to squeel
+
+      # Retrieve the author's unique identifier
+      subquery = 'SELECT socializer_activity_objects.id ' \
+                 'FROM socializer_activity_objects ' \
+                 'INNER JOIN socializer_people ' \
+                 'ON socializer_activity_objects.activitable_id = socializer_people.id ' \
+                 'WHERE socializer_people.id = socializer_activities.actor_id'
+
+      Circle.select { id }.where { author_id.in(`#{subquery}`) }
+    end
+
+    # Audience : LIMITED
+    # Ensure that the audience is LIMITED and then make sure that the viewer is either
+    # part of a circle that is the target audience, or that the viewer is part of
+    # a group that is the target audience, or that the viewer is the target audience.
+    def self.build_limited_circle_subquery(viewer_id)
+      # TODO: Convert this to squeel
+
+      # Retrieve the circle's unique identifier related to the audience (when the audience
+      # is not a circle, this query will simply return nothing)
+      limited_circle_id_sql = 'SELECT socializer_circles.id ' \
+                              'FROM socializer_circles ' \
+                              'INNER JOIN socializer_activity_objects ' \
+                              'ON socializer_circles.id = socializer_activity_objects.activitable_id ' \
+                                  "AND socializer_activity_objects.activitable_type = 'Socializer::Circle' " \
+                              'WHERE socializer_activity_objects.id = socializer_audiences.activity_object_id '
+
+      # Retrieve all the contacts (people) that are part of those circles
+      Tie.select { contact_id }.where { circle_id.in(`#{limited_circle_id_sql}`) }
+
+      # Ensure that the audience is LIMITED and then make sure that the viewer is either
+      # part of a circle that is the target audience, or that the viewer is part of
+      # a group that is the target audience, or that the viewer is the target audience.
+      # limited_sql = Audience.with_privacy_level(:limited).where{(`"#{viewer_id}"`.in(actor_circles_sql)) | (activity_object_id.in(limited_groups_sql)) | (activity_object_id.eq(viewer_id))}
+    end
+
+    def self.build_limited_group_subquery(viewer_id)
+      ActivityObject.select { id }.joins { activitable(Group).memberships }.where { socializer_memberships.member_id.eq(viewer_id) }
+    end
+
+    def self.build_limited_viewer_subquery(viewer_id)
+      "( #{viewer_id} )"
+    end
+  end
+end

data/app/models/socializer/activity_field.rb

@@ -0,0 +1,10 @@
+module Socializer
+  class ActivityField < ActiveRecord::Base
+    attr_accessible :content, :activity
+
+    belongs_to :activity, inverse_of: :activity_field
+
+    validates :content,  presence: true
+    validates :activity, presence: true
+  end
+end

data/app/models/socializer/activity_object.rb

@@ -0,0 +1,118 @@
+module Socializer
+  class ActivityObject < ActiveRecord::Base
+    attr_accessor :scope, :object_ids
+    attr_accessible :scope, :object_ids, :activitable_id, :activitable_type, :like_count, :unread_notifications_count
+
+    belongs_to :activitable, polymorphic: true
+
+    has_many :notifications
+    has_many :audiences # , dependent: :destroy
+    # FIXME: This shouldn't need source. See if it is fixed in Rails 4 RC2 or Final
+    has_many :activities, through: :audiences, source: :activity
+
+    has_many :actor_activities,  class_name: 'Activity', foreign_key: 'actor_id',  dependent: :destroy
+    has_many :object_activities, class_name: 'Activity', foreign_key: 'activity_object_id', dependent: :destroy
+    has_many :target_activities, class_name: 'Activity', foreign_key: 'target_id', dependent: :destroy
+
+    # when the embedded object is an actor (person/group)
+    # it can be the owner of certain objects.
+    has_many :notes,      foreign_key: 'author_id'
+    has_many :comments,   foreign_key: 'author_id'
+    has_many :groups,     foreign_key: 'author_id'
+    has_many :circles,    foreign_key: 'author_id'
+
+    has_many :ties,        foreign_key: 'contact_id'
+    has_many :memberships, -> { where active: true }, foreign_key: 'member_id'
+
+    # define a class macro for setting comparaison with activitable_type
+    def self.attribute_type_of(*args)
+      args.each do |type|
+        define_method("#{type}?") { activitable_type == "Socializer::#{type.capitalize}" }
+      end
+    end
+
+    attribute_type_of :note, :activity, :comment, :person, :group, :circle
+
+    # REFACTOR: DRY this up. Reduce database calls
+    # TODO: Rename this method to liked_by
+    def likes
+      people = []
+      query  =  Activity.joins { verb }.where { activity_object_id.eq(my { id }) }
+
+      activities_likes = query.where { verb.name.eq('like') }
+      activities_likes.each do |activity|
+        people.push activity.actor
+      end
+
+      activities_unlikes = query.where { verb.name.eq('unlike') }
+      activities_unlikes.each do |activity|
+        people.delete_at people.index(activity.actor)
+      end
+
+      people
+    end
+
+    def like!(person)
+      activity = Activity.create! do |a|
+        a.actor_id = person.activity_object.id
+        a.activity_object_id = id
+        a.verb = Verb.find_or_create_by(name: 'like')
+      end
+
+      Audience.create!(privacy_level: :public, activity_id: activity.id)
+
+      increment_like_count
+    end
+
+    def unlike!(person)
+      activity = Activity.create! do |a|
+        a.actor_id = person.activity_object.id
+        a.activity_object_id = id
+        a.verb = Verb.find_or_create_by(name: 'unlike')
+      end
+
+      Audience.create!(privacy_level: :public, activity_id: activity.id)
+
+      decrement_like_count
+    end
+
+    def share!
+      public = Socializer::Audience.privacy_level.find_value(:public).value.to_s
+      circles = Socializer::Audience.privacy_level.find_value(:circles).value.to_s
+
+      activity = Activity.new do |a|
+        a.actor_id = actor_id
+        a.activity_object_id = id
+        a.verb = Verb.find_or_create_by(name: 'share')
+      end
+
+      # REFACTOR: remove duplication
+      if scope == public || scope == circles
+        activity.audiences.build(privacy_level: scope)
+      else
+        object_ids.each do |object_id|
+          activity.audiences.build do |a|
+            a.privacy_level = :limited
+            a.activity_object_id = object_id
+          end
+        end
+      end
+
+      activity.save!
+    end
+
+    def increment_unread_notifications_count
+      increment!(:unread_notifications_count)
+    end
+
+    private
+
+    def increment_like_count
+      increment!(:like_count)
+    end
+
+    def decrement_like_count
+      decrement!(:like_count)
+    end
+  end
+end

data/app/models/socializer/audience.rb

@@ -0,0 +1,19 @@
+module Socializer
+  class Audience < ActiveRecord::Base
+    extend Enumerize
+
+    enumerize :privacy_level, in: { public: 1, circles: 2, limited: 3 }, default: :public, predicates: true, scope: true
+
+    attr_accessible :activity_id, :privacy_level
+
+    belongs_to :activity
+    belongs_to :activity_object
+
+    validates :activity_id, presence: true, uniqueness: { scope: :activity_object_id }
+    validates :privacy_level, presence: true
+
+    def object
+      @object ||= activity_object.activitable
+    end
+  end
+end

data/app/models/socializer/authentication.rb

@@ -0,0 +1,20 @@
+module Socializer
+  class Authentication < ActiveRecord::Base
+    attr_accessible :provider, :uid, :image_url
+
+    belongs_to :person
+
+    before_destroy :make_sure_its_not_the_last_one
+
+    private
+
+    def make_sure_its_not_the_last_one
+      if person.authentications.count == 1
+        # FIXME: authentication - This is not be a good user experience.
+        #       If the user clicks 'unbind' on their last authentication they will get an error.
+        #       A flash notice should be set and the user should be able to continue on.
+        fail 'Cannot delete the last authentication available.'
+      end
+    end
+  end
+end

data/app/models/socializer/circle.rb

@@ -0,0 +1,32 @@
+module Socializer
+  class Circle < ActiveRecord::Base
+    include Socializer::ObjectTypeBase
+
+    attr_accessible :name, :content
+
+    belongs_to :activity_author,  class_name: 'ActivityObject', foreign_key: 'author_id'
+
+    has_many   :ties
+    has_many   :activity_contacts, through: :ties
+
+    validates :name, presence: true, uniqueness: { scope: :author_id }
+
+    def author
+      @author ||= activity_author.activitable
+    end
+
+    def contacts
+      @contacts ||= activity_contacts.map { |ec| ec.activitable }
+    end
+
+    def add_contact(contact_id)
+      @tie = ties.build(contact_id: contact_id)
+      @tie.save
+    end
+
+    def remove_contact(contact_id)
+      @tie = ties.find_by(contact_id: contact_id)
+      @tie.destroy
+    end
+  end
+end

data/app/models/socializer/comment.rb

@@ -0,0 +1,13 @@
+module Socializer
+  class Comment < ActiveRecord::Base
+    include Socializer::ObjectTypeBase
+
+    attr_accessible :content
+
+    belongs_to :activity_author, class_name: 'ActivityObject', foreign_key: 'author_id'
+
+    def author
+      @author ||= activity_author.activitable
+    end
+  end
+end

data/app/models/socializer/group.rb

@@ -0,0 +1,100 @@
+module Socializer
+  class Group < ActiveRecord::Base
+    extend Enumerize
+    include Socializer::ObjectTypeBase
+
+    enumerize :privacy_level, in: { public: 1, restricted: 2, private: 3 }, default: :public, predicates: true, scope: true
+
+    attr_accessible :name, :privacy_level, :author_id
+
+    # Relationships
+    belongs_to :activity_author,  class_name: 'ActivityObject', foreign_key: 'author_id'
+
+    has_many :memberships
+    has_many :activity_members, -> { where(socializer_memberships: { active: true }) }, through: :memberships
+    has_many :links, class_name: 'GroupLink', foreign_key: 'group_id', dependent: :destroy
+    has_many :categories, class_name: 'GroupCategory', foreign_key: 'group_id', dependent: :destroy
+
+    # Validations
+    validates :author_id, presence: true
+    validates :name, presence: true, uniqueness: { scope: :author_id }
+    validates :privacy_level, presence: true
+
+    # Callbacks
+    after_create   :add_author_to_members
+    before_destroy :deny_delete_if_members
+
+    # Named Scopes
+
+    # Class Methods
+    def self.public
+      Group.with_privacy_level(:public)
+    end
+
+    def self.restricted
+      Group.with_privacy_level(:restricted)
+    end
+
+    def self.private
+      Group.with_privacy_level(:private)
+    end
+
+    def self.joinable
+      Group.with_privacy_level(:public, :restricted)
+    end
+
+    # Instance Methods
+    def author
+      @author ||= activity_author.activitable
+    end
+
+    def members
+      @members ||= activity_members.map { |em| em.activitable }
+    end
+
+    def join(person)
+      @membership = person.memberships.build(group_id: id)
+
+      if privacy_level.public?
+        @membership.active = true
+      elsif privacy_level.restricted?
+        @membership.active = false
+      else
+        fail 'Cannot self-join a private group, you need to be invited'
+      end
+
+      @membership.save
+    end
+
+    def invite(person)
+      @membership = person.memberships.build(group_id: id)
+
+      @membership.active = false
+      @membership.save
+    end
+
+    def leave(person)
+      @membership = person.memberships.find_by(group_id: id)
+      @membership.destroy
+    end
+
+    def member?(person)
+      person.memberships.find_by(group_id: id).present?
+    end
+
+    private
+
+    def add_author_to_members
+      @membership = author.memberships.build(group_id: id)
+
+      @membership.active = true
+      @membership.save
+    end
+
+    def deny_delete_if_members
+      if memberships.count > 0
+        fail 'Cannot delete a group that has members in it.'
+      end
+    end
+  end
+end