social_engine 0.0.1

data/app/controllers/social_engine_controller.rb

@@ -0,0 +1,32 @@
+require 'digest/sha2'
+module SocialEngineController
+
+  def add_fingerprint_and_user_id(obj,save=false)
+    obj[:ip_address]=request.remote_ip
+    obj[:session_hash]=request.session_options[:id]
+    obj[:browser_fingerprint]=browser_fingerprint
+    obj[:user_id] = current_user.id if current_user
+    obj.save if save
+  end
+  
+  def add_able_rep(name,obj)
+    able = able_method_name(obj)
+    if obj and obj.send(able) and obj.send(able).respond_to?(:user)
+      Reputation.add(name, obj.send(able).user) rescue nil
+    end
+  end
+  
+  def browser_fingerprint
+    Digest::SHA2.hexdigest(request.user_agent+request.accept+request.accept_charset+request.accept_encoding+request.accept_language) rescue nil
+  end
+  
+  def set_polymorphic_vars(obj,able_method=nil)
+    able = able_method || able_method_name(obj)
+    obj.send("#{able}_type=", request.path.split("/")[1].classify)
+    obj.send("#{able}_id=", request.path.split("/")[2])
+  end
+  
+  def able_method_name(obj)
+    "#{obj.class.to_s.underscore}able"
+  end
+end

data/app/controllers/votes_controller.rb

@@ -0,0 +1,15 @@
+class VotesController < InheritedResources::Base
+  def create
+    @vote = Vote.new(params[:vote])
+    set_polymorphic_vars(@vote)
+    add_fingerprint_and_user_id(@vote)
+    create! do |success, failure|
+      success.html do
+        add_able_rep("upvote",@vote) if @vote.up?
+        add_able_rep("downvote",@vote) if @vote.down?
+        redirect_to :back
+      end
+      failure.html { redirect_to :back }
+    end
+  end
+end

data/app/helpers/social_engine_helper.rb

@@ -0,0 +1,82 @@
+module SocialEngineHelper
+  def tweetme(options={})
+    defaults = {count: SocialEngineYetting.tweetme["count"], url: request.url, div_class: SocialEngineYetting.tweetme["div_class"]}
+    options.reverse_merge!(defaults)
+    render "third_party/tweetme", options: options
+  end
+  
+  def fb_like(options={})
+    defaults = get_defaults(:fb_like)
+    options.reverse_merge!(defaults)
+    options.reverse_merge!(:url=>request.url)
+    render "third_party/fblike", options: options
+  end
+  
+  def fb_friend_box(options={})
+    defaults = get_defaults(:fb_friend_box)            
+    options.reverse_merge!(defaults)
+    render "third_party/fb_friend_box", options: options
+  end
+  
+  def fb_og_tags(options={})
+    defaults = get_defaults(:fb_og_tags)
+    options.reverse_merge!(defaults)
+    render "third_party/fb_og_tags", options: options
+  end
+  
+  def fb_javascript_sdk(options={})
+    defaults = get_defaults(:fb_javascript_sdk)
+    options.reverse_merge!(defaults)
+    render "third_party/fb_javascript_sdk", options: options
+  end
+  
+  def comment_form(commentable,*options)
+    options = options.to_options_hash
+    defaults = get_defaults(:comment_form)
+    options.optional_reverse_merge!(defaults, [:comment])
+    render "comments/form", commentable: commentable, comment: Comment.new, options: options
+  end
+  
+  def comments_list(commentable, options={})
+    defaults = get_defaults(:comment_list)
+    options.reverse_merge!(defaults)
+    comments = commentable.comments.order("id #{options[:order]}")
+    comments = comments.limit(options[:display_limit]) if options[:display_limit].is_a? Fixnum
+    render "comments/list", commentable: commentable, options: options, comments: comments
+  end
+  
+  def favorites_widget(favoriteable,options={})
+    if current_user
+      defaults = get_defaults(:favorites_widget)
+      options.reverse_merge!(defaults)
+      favorite = Favorite.where(favoriteable_type:favoriteable.class.to_s, favoriteable_id: favoriteable.id, user_id: current_user.id).first rescue Favorite.new
+      render "favorites/widget", favoriteable: favoriteable, favorite: favorite, options: options
+    end
+  end
+
+  def vote_widget(voteable,options={})
+    defaults = get_defaults(:vote_widget)
+    options.reverse_merge!(defaults)
+    render "votes/widget", voteable: voteable, options: options
+  end
+
+  ##
+  def rating_form(rateable,options={})
+    defaults = get_defaults(:rating_form)
+    options.reverse_merge!(defaults)
+    render "ratings/form",  rateable: rateable, rating: Rating.new, options: options
+  end
+    
+  def get_defaults(key)
+    begin
+      SocialEngineYetting.send(key).symbolize_keys! 
+    rescue
+      puts "WARNING: Defaults not found for #{key} in SocialEngineYettings.  This key is missing from config/yettings/social_engine.yml"
+      return {}
+    end
+  end
+  
+  def div_id(klass)
+    "se-#{klass.class.to_s.underscore.gsub('_','-')}#{klass.id}"
+  end
+end

data/app/models/comment.rb

@@ -0,0 +1,10 @@
+class Comment < ActiveRecord::Base
+  belongs_to :commentable, :polymorphic=>true
+  belongs_to :user
+  validates_presence_of :comment
+  is_voteable
+  is_commentable
+  is_rateable
+
+  include SocialEngine::Helpers::User
+end

data/app/models/favorite.rb

@@ -0,0 +1,4 @@
+class Favorite < ActiveRecord::Base
+  belongs_to :favoriteable, :polymorphic=>true
+  belongs_to :user
+end

data/app/models/friending.rb

@@ -0,0 +1,21 @@
+class Friending < ActiveRecord::Base
+  belongs_to :friendee, :class_name=>'User'
+  belongs_to :friendor, :class_name=>'User'
+  validates_uniqueness_of :friendee_id, :scope=> :friendor_id
+  validate :not_friending_self
+
+  def confirm
+    self.update_attributes(:confirmed=>true)
+  end
+
+  def reject
+    self.update_attributes(:rejected=>true)
+  end
+
+private
+  def not_friending_self
+    errors.add(:friendee_id, "can't be the same as friendor_id") if
+      friendee_id == friendor_id
+  end
+
+end

data/app/models/rating.rb

@@ -0,0 +1,6 @@
+class Rating < ActiveRecord::Base
+  belongs_to :rateable, :polymorphic=>true
+  belongs_to :user  
+  validates_uniqueness_of :rateable_type, :scope=> SocialEngine::Helpers::Fingerprint.fingerprint_type(:rateable_id),
+                          :if => Proc.new { |x| SocialEngineYetting.fingerprint_method != "none" }
+end

data/app/models/reputation.rb

@@ -0,0 +1,24 @@
+class Reputation < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :reputation_action
+  
+  def self.add(name,*users)
+    reputation_action = ReputationAction.where(:name=>name).first
+    if reputation_action.present? and users
+      users.each do |user|
+        if user.present?
+          self.create(:user_id=>user.id,:reputation_action_id=>reputation_action.id,:value=>reputation_action.value)
+          self.update_user_rep(user,reputation_action.value)
+        end
+      end
+    end
+  end
+  
+  def self.update_user_rep(user,value)
+    if SocialEngineYetting.reputation["update_user_model"]
+      rep_field = SocialEngineYetting.reputation["user_model_rep_field_name"].to_s.to_sym
+      new_rep_value = user.send(rep_field).to_i + value
+      user.update_attributes(rep_field=>new_rep_value)
+    end
+  end
+end

data/app/models/reputation_action.rb

@@ -0,0 +1,15 @@
+class ReputationAction < ActiveRecord::Base
+  has_many :reputations, :dependent=>:destroy
+  
+  def self.list_from_rails_source
+    list = []
+    files = Dir.glob("{#{Rails.root.to_s},#{SocialEngine::Engine.root.to_s}}/app/{controllers,models}/**/*.rb")
+    files.each do |file|
+      source = IO.read(file)
+      source.scan(/(Reputation.add|add_able_rep)\(("|')(.*)("|'),.*\)/).each do |line|
+        list << line[2] if line[2].present?
+      end
+    end
+    list
+  end
+end

data/app/models/social_engine/commentable.rb

@@ -0,0 +1,14 @@
+module SocialEngine
+  module Commentable
+    def is_commentable
+      has_many :comments, :as=>:commentable, :dependent => :destroy
+      include InstanceMethods
+    end
+    
+    module InstanceMethods
+      def commentable?
+        true
+      end
+    end
+  end
+end

data/app/models/social_engine/favoriteable.rb

@@ -0,0 +1,14 @@
+module SocialEngine
+  module Favoriteable
+    def is_favoriteable
+      has_many :favorites, :as=>:favoriteable, :dependent => :destroy
+      include InstanceMethods
+    end
+    
+    module InstanceMethods
+      def favoriteable?
+        true
+      end
+    end
+  end
+end

data/app/models/social_engine/friendable.rb

@@ -0,0 +1,56 @@
+module SocialEngine
+  module Friendable
+    def is_friendable
+
+      # Setup conditions
+      active = ["confirmed = ? AND rejected = ?", true, false]
+      pending = ["confirmed = ?", false]
+      requested = ["confirmed = ? AND rejected = ?", false, false]
+      rejected = ["rejected = ?", true]
+
+      # Active friendships
+      has_many :friendorings, :class_name=>'Friending',
+               :foreign_key=>:friendee_id, :conditions=>active
+      has_many :friendeeings, :class_name=>'Friending',
+               :foreign_key=>:friendor_id, :conditions=>active
+      # Pending friend requests from the user
+      has_many :pending_friendships, :class_name=>'Friending',
+               :foreign_key=>:friendor_id, :conditions=>pending
+      # Pending friend requests to the user
+      has_many :friend_requests, :class_name=>'Friending',
+               :foreign_key=>:friendee_id, :conditions=>requested
+      # Friend requests rejected by the user
+      has_many :friend_rejections, :class_name=>'Friending',
+               :foreign_key=>:friendee_id, :conditions=>rejected
+
+      # Friend relations (these return collections of Users)
+      has_many :friendors, :through=>:friendorings, :class_name=>'User'
+      has_many :friendees, :through=>:friendeeings, :class_name=>'User'
+      has_many :pending_friends, :through=>:pending_friendships,
+               :source=>:friendee, :class_name=>'User'
+      has_many :requesting_friends, :through=>:friend_requests,
+               :source=>:friendor, :class_name=>'User'
+      has_many :rejected_friends, :through=>:friend_rejections,
+               :source=>:friendor, :class_name=>'User'
+
+      include InstanceMethods
+    end
+    
+    module InstanceMethods      
+      def friendable?
+        true
+      end
+      
+      def friends(expire_association_cache=false)
+        return self.friendors(true) + self.friendees(true) if expire_association_cache
+        self.friendors + self.friendees
+      end
+
+      def add_friend(user)
+        Friending.create(:friendor_id=>self.id, :friendee_id=>user.id,
+                         :confirmed=>!SocialEngineYetting.confirm_friends)
+      end
+      
+    end
+  end
+end

data/app/models/social_engine/helpers.rb

@@ -0,0 +1,37 @@
+module SocialEngine
+  module Helpers  
+    module User
+      def name
+        self.user ? self.user.name : self.unauthenticated_name
+      end
+
+      def email
+        self.user ? self.user.email : self.unauthenticated_email
+      end
+
+      def website
+        self.user ? self.user.website : self.unauthenticated_website
+      end
+    end
+    
+    module Fingerprint
+      def self.fingerprint_type(able)
+        ftype = [able]
+        fingerprint = SocialEngineYetting.fingerprint_method rescue nil
+        case fingerprint
+        when "ip_address"
+          ftype << :ip_address
+        when "session_hash"
+          ftype << :session_hash
+        when "browser"
+          ftype << :browser_fingerprint      
+        when "ip_browser"
+          ftype.concat [:ip_browser,:browser_fingerprint]
+        when "none"
+          ftype = [:none]
+        end
+        ftype
+      end
+    end
+  end
+end

data/app/models/social_engine/rateable.rb

@@ -0,0 +1,33 @@
+module SocialEngine
+  module Rateable
+    def is_rateable
+      has_many :ratings, :as=>:rateable, :dependent=>:destroy
+      include InstanceMethods
+    end
+    
+    module InstanceMethods
+      def rateable?
+        true
+      end
+      
+      def avg_rating
+        avg = self.ratings.sum(:value).to_f/self.rating_count.to_f rescue 0
+        avg = 0 if avg.nan?
+        avg
+      end
+      
+      def avg_rating_formatted(decimal_places=1)
+        return self.avg_rating.to_i.to_s if decimal_places==0
+        sprintf("%.#{decimal_places}f", self.avg_rating)
+      end
+      
+      def rating_count
+        self.ratings.size
+      end
+      
+      def avg_rating_round_half
+        (avg_rating*2).round / 2.0
+      end
+    end
+  end
+end

data/app/models/social_engine/reputatable.rb

@@ -0,0 +1,14 @@
+module SocialEngine
+  module Reputatable
+    def has_reputation
+      has_many :reputations
+      include InstanceMethods
+    end
+    
+    module InstanceMethods
+      def has_reputation?
+        true
+      end
+    end
+  end
+end

data/app/models/social_engine/sociable.rb

@@ -0,0 +1,17 @@
+module SocialEngine
+  module Sociable
+    def is_sociable
+      is_rateable
+      is_voteable
+      is_commentable
+      is_favoriteable
+      include InstanceMethods
+    end
+    
+    module InstanceMethods
+      def sociable?
+        true
+      end
+    end
+  end
+end

data/app/models/social_engine/social_user.rb

@@ -0,0 +1,16 @@
+module SocialEngine
+  module SocialUser
+    def is_social
+      has_many :comments
+      has_many :votes
+      has_many :ratings
+      has_many :favorites
+      include InstanceMethods
+    end
+    module InstanceMethods
+      def is_social?
+        true
+      end
+    end
+  end
+end

data/app/models/social_engine/voteable.rb

@@ -0,0 +1,28 @@
+module SocialEngine
+  module Voteable
+    def is_voteable
+      has_many :votes, :as=>:voteable, :dependent=>:destroy
+      include InstanceMethods
+    end
+    
+    module InstanceMethods
+      def voteable?
+        true
+      end
+      
+      def upvote(options={})
+        options.reverse_merge!(:value=>1)
+        self.votes.create(options)
+      end
+      
+      def downvote(options={})
+        options.reverse_merge!(:value=>-1)
+        self.votes.create(options)
+      end
+      
+      def vote_sum
+        self.votes.inject(0){|sum,vote| sum = sum + vote.value}
+      end      
+    end
+  end
+end