muck-services 0.1.2

data/app/helpers/muck_services_service_helper.rb

@@ -0,0 +1,117 @@
+module MuckServicesServiceHelper
+  
+  # Render a summary of all services for the given parent.  The parent should 'acts_as_muck_feed_owner' 
+  def services_summary(parent)
+    identity_feeds = parent.identity_feeds.find(:all, :include => [{:feed => :service}])
+    render :partial => 'services/summary', :locals => { :identity_feeds => identity_feeds }
+  end
+  
+  # Render a view with all services in categories.
+  # service_categories: Results from a query to service_categories.  For performance try something like this:
+  #                     ServiceCategory.sorted.find(:all, :include => [:identity_services])
+  # title: Optional title.  Default is 'Available Services' - from I18n.t('muck.services.available_services')
+  # css: Optional css to be added to the div that surrounds the categories
+  def available_service_categories(service_categories, title = nil, css = '')
+    render :partial => 'identity_feeds/available_service_categories', :locals => { :service_categories => service_categories, :css => css, :title => title }
+  end
+  
+  # Render a view with the user's registered services.
+  # identity_feeds: Results from a query to service_categories.  For performance try something like this:
+  #                 @user.identity_feeds.find(:all, :include => [{:feed => :service}])
+  # title: Optional title.  Default is 'My Services' - from I18n.t('muck.services.my_services')
+  # css: Optional css to be added to the div that surrounds the categories
+  def services_for_user(identity_feeds, title = nil, css = '')
+    render :partial => 'identity_feeds/services_for_user', :locals => { :identity_feeds => identity_feeds, :css => css, :title => title, :edit => false }
+  end
+  
+  # Render an edit view with the user's registered services.
+  # identity_feeds: Results from a query to service_categories.  For performance try something like this:
+  #                 @user.identity_feeds.find(:all, :include => [{:feed => :service}])
+  # title: Optional title.  Default is 'My Services' - from I18n.t('muck.services.my_services')
+  # css: Optional css to be added to the div that surrounds the categories
+  def services_for_user_edit(identity_feeds, title = nil, css = '')
+    render :partial => 'identity_feeds/services_for_user', :locals => { :identity_feeds => identity_feeds, :css => css, :title => title, :edit => true }
+  end
+  
+  # Renders an icon for the given service
+  # Name is the name of the image file associated with the service
+  # Size can be one of 16, 24, 48 or 60.
+  def service_icon(name, size = 24)
+    %Q{<img src="/images/service_icons/#{size}/#{name}" />}
+  end
+  
+  def service_image(name, size = 24)
+    %Q{/images/service_icons/#{size}/#{name}}
+  end
+  
+  # Renders name and icon for the service
+  def service_title(service)
+    %Q{<div class="identity-service-title" #{service_icon_background(service)}>#{service_prompt(service)}</div>}
+  end
+  
+  # By default renders Service username e.g. Flickr username
+  # If the service has a 'prompt' set it will look for a value in the localization
+  # files.  For example, setting service.prompt to 'blog_url' will cause this method
+  # to look for a translation at muck.services.blog_url and will pass the name of the service
+  # using 'service' so your translation might look like:
+  # muck.services.blog_url: "Blog Url" or
+  # muck.services.facebook_prompt: "{{service}} Feeds"
+  def service_prompt(service)
+    if @service.prompt.blank?
+      I18n.t('muck.services.service_username', :service => @service.name)
+    else
+      I18n.t("muck.services.#{@service.prompt}", :service => @service.name)
+    end
+  end
+  
+  # Renders a link for a new user service with class 'lightbox' or optional css set on the link.
+  def service_lightbox(parent, service, link_css = 'lightbox', wrapper = 'li')
+    path = new_polymorphic_url([parent, :identity_feed], :service_id => service.to_param)
+    service_link(path, service, link_css, wrapper, nil, nil, "#{service.name.parameterize}-link")
+  end
+
+  # Renders a link for editing a user feed with class 'lightbox' or optional css set on the link.
+  def service_lightbox_edit(parent, identity_feed, link_css = 'lightbox', wrapper = nil)
+    path = edit_polymorphic_url([parent, identity_feed])
+    link_text = identity_feed.feed.title unless identity_feed.feed.title.blank?
+    service_link(path, identity_feed.feed.service, link_css, wrapper, link_text)
+  end
+  
+  def service_external_link(identity_feed, link_css = nil, wrapper = nil)
+    path = identity_feed.feed.display_uri || identity_feed.feed.uri
+    link_text = identity_feed.feed.title unless identity_feed.feed.title.blank?
+    service_link(path, identity_feed.feed.service, link_css, wrapper, link_text, 'blank')
+  end
+  
+  # Renders a delete button for an identity_feed
+  def service_delete(identity_feed, button_type = :button, button_text = t("muck.general.delete"))
+    render :partial => 'shared/delete', :locals => { :delete_object => identity_feed, 
+                                                     :button_type => button_type,
+                                                     :button_text => button_text,
+                                                     :form_class => 'identity-feed-delete',
+                                                     :delete_path => identity_feed_path(identity_feed, :format => 'js') }
+  end
+  
+  # Renders a service link optionally wrapping it in the specified element
+  def service_link(path, service, link_css, wrapper, link_text = nil, target = nil, id = nil)
+    link = %Q{<a #{'id=' + id if id} href="#{path}" #{service_icon_background(service)} #{'target=' + target if target} class="service-link #{link_css}">#{link_text || service.name}</a>}
+    if wrapper
+      content_tag wrapper, link, :class => 'identity-service' 
+    else
+      link
+    end
+  end
+  
+  def service_icon_background(service)
+    %Q{style="background: transparent url('#{service_image(service.icon, 24)}') no-repeat scroll left top;"}
+  end
+  
+  def url_by_identity_feed(owner, identity_feed, service)
+    if identity_feed
+      polymorphic_url([owner, identity_feed], :service_id => service.to_param)
+    else
+      polymorphic_url([owner, :identity_feeds], :service_id => service.to_param)
+    end
+  end
+  
+end

data/app/models/aggregation.rb

@@ -0,0 +1,92 @@
+# == Schema Information
+#
+# Table name: aggregations
+#
+#  id           :integer(4)      not null, primary key
+#  terms         :string(255)
+#  title        :string(255)
+#  description  :text
+#  top_tags     :text
+#  created_at   :datetime
+#  updated_at   :datetime
+#  ownable_id   :integer(4)
+#  ownable_type :string(255)
+#
+
+class Aggregation < ActiveRecord::Base
+  unloadable
+
+  has_friendly_id :terms, :use_slug => true
+  
+  belongs_to :ownable, :polymorphic => true
+  has_many :aggregation_feeds
+  has_many :feeds, :through => :aggregation_feeds
+  
+  named_scope :by_title, :order => "title ASC"
+  named_scope :recent, lambda { { :conditions => ['created_at > ?', 1.week.ago] } }
+  named_scope :newest, :order => "created_at DESC"
+    
+  # Builds and then adds feeds for a given terms
+  # user:         User to be associated with each feed.  Default is nil which makes each feed global.
+  # service_ids:  An array of service ids.  Nil will generate a feed for every available service.
+  # refresh_services:     By default all tag services are cached.  Setting this value to true
+  #                       will result in the values being repopulated from the database
+  def add_feeds(user = nil, service_ids = nil, refresh_services = false)
+    safe_add_feeds(Service.create_tag_feeds(self.terms, user, service_ids, refresh_services))
+  end
+  
+  def add_feeds_by_uri(user = nil, uris = nil)
+    safe_add_feeds(Feed.create_tag_feeds(user, uris))
+  end
+  
+  # Only add feeds that aren't already part of the aggregation
+  def safe_add_feeds(new_feeds)
+    new_feeds.each do |feed|
+      begin
+        self.feeds << feed
+      rescue ActiveRecord::RecordInvalid => ex
+        # Throw away exception.  Feed already exists so we don't need to do anything.
+      end
+    end
+    new_feeds
+  end
+  
+  # Get only photo feeds
+  def photo_feeds(refresh_services = false)
+    all_feeds.find_all{ |feed| feed.service.photo?(refresh_services) rescue nil }
+  end
+  
+  # Get only video feeds
+  def video_feeds(refresh_services = false)
+    all_feeds.find_all{ |feed| feed.service.video?(refresh_services) rescue nil }
+  end
+  
+  # Get only bookmark feeds
+  def bookmark_feeds(refresh_services = false)
+    all_feeds.find_all{ |feed| feed.service.bookmark?(refresh_services) rescue nil }
+  end
+
+  # Get only music feeds
+  def music_feeds(refresh_services = false)
+    all_feeds.find_all{ |feed| feed.service.music?(refresh_services) rescue nil}
+  end
+
+  # Get only general feeds (exclude all specific feeds such as photos, videos, etc)
+  def general_feeds(refresh_services = false)
+    all_feeds.find_all{ |feed| feed.service.general?(refresh_services) rescue nil }
+  end
+  
+  def all_feeds
+    @all_feeds ||= self.feeds.find(:all, :include => :service)
+  end
+
+  # Determines whether or not he given user can edit the aggregation
+  def can_edit?(user)
+    if ownable == user || user.admin?
+      true
+    else
+      false
+    end
+  end
+  
+end

data/app/models/aggregation_feed.rb

@@ -0,0 +1,14 @@
+# == Schema Information
+#
+# Table name: aggregation_feeds
+#
+#  id             :integer(4)      not null, primary key
+#  aggregation_id :integer(4)
+#  feed_id        :integer(4)
+#
+
+class AggregationFeed < ActiveRecord::Base
+  belongs_to :aggregation, :counter_cache => 'feed_count', :touch => true
+  belongs_to :feed
+  validates_uniqueness_of :feed_id, :scope => :aggregation_id
+end

data/app/models/attention.rb

@@ -0,0 +1,14 @@
+# == Schema Information
+#
+# Table name: attentions
+#
+#  id                 :integer(4)      not null, primary key
+#  attentionable_id   :integer(4)
+#  attentionable_type :string(255)
+#  entry_id           :integer(4)
+#  action_type        :string(255)
+#  weight             :float
+#
+
+class Attention < ActiveRecord::Base
+end

data/app/models/click.rb

@@ -0,0 +1,14 @@
+# == Schema Information
+#
+# Table name: clicks
+#
+#  id                :integer(4)      not null, primary key
+#  recommendation_id :integer(4)
+#  when              :datetime        not null
+#  referrer          :string(2083)
+#  requester         :string(255)
+#  user_agent        :string(2083)
+#
+
+class Click < ActiveRecord::Base
+end

data/app/models/entry.rb

@@ -0,0 +1,341 @@
+# == Schema Information
+#
+# Table name: entries
+#
+#  id                      :integer(4)      not null, primary key
+#  feed_id                 :integer(4)      not null
+#  permalink               :string(2083)    default(""), not null
+#  author                  :string(2083)
+#  title                   :text            default(""), not null
+#  description             :text
+#  content                 :text
+#  unique_content          :boolean(1)
+#  published_at            :datetime        not null
+#  entry_updated_at        :datetime
+#  harvested_at            :datetime
+#  oai_identifier          :string(2083)
+#  language_id             :integer(4)
+#  direct_link             :string(2083)
+#  indexed_at              :datetime        default(Fri Jan 01 01:01:01 UTC 1971), not null
+#  relevance_calculated_at :datetime        default(Fri Jan 01 01:01:01 UTC 1971), not null
+#  popular                 :text
+#  relevant                :text
+#  other                   :text
+#  grain_size              :string(255)     default("unknown")
+#
+# Indexes
+#
+#  index_entries_on_direct_link              (direct_link)
+#  index_entries_on_feed_id                  (feed_id)
+#  index_entries_on_indexed_at               (indexed_at)
+#  index_entries_on_language_id              (language_id)
+#  index_entries_on_oai_identifier           (oai_identifier)
+#  index_entries_on_permalink                (permalink)
+#  index_entries_on_published_at             (published_at)
+#  index_entries_on_relevance_calculated_at  (relevance_calculated_at)
+#  index_entries_on_grain_size               (grain_size)
+#
+
+class Entry < ActiveRecord::Base
+  
+  unloadable
+  
+  belongs_to :feed
+  belongs_to :language
+  has_many :activities, :as => :attachable, :dependent => :destroy
+  has_many :attentions, :dependent => :destroy
+  acts_as_commentable
+  acts_as_taggable
+  
+  @@default_time_on_page = 60.0
+  
+  acts_as_solr({:if => false, :fields => [{:feed_id => :integer}, {:grain_size => :string}]}, {:type_field => :type_s})
+
+  def resource_uri 
+    self.direct_link.nil? ? self.permalink : self.direct_link
+  end
+  
+  def self.top_tags(tags = nil)
+    
+  end
+  
+  def self.search(search_terms, grain_size = nil, language = "en", limit = 10, offset = 0, operator = :or)
+    raise MuckServices::Exceptions::LanguageNotSupported, I18n.t('muck.services.language_not_supported') unless Recommender::Languages.supported_languages.include?(language)
+    query = (!grain_size.nil? && grain_size != 'all') ? (search_terms + ") AND (grain_size:#{grain_size}") : search_terms
+    return find_by_solr(query, :limit => limit, :offset => offset, :scores => true, :select => "entries.id, entries.title, entries.permalink, entries.direct_link, entries.published_at, entries.description, entries.feed_id, feeds.short_title AS collection", :joins => "INNER JOIN feeds ON feeds.id = entries.feed_id", :core => language, :operator => operator)
+  end
+
+  def self.recommender_entry(uri)
+    uri = normalized_uri(uri)
+    Entry.find(:first, :conditions => ['permalink = ? OR direct_link = ?', uri, uri], :order => 'direct_link IS NULL DESC') || Entry.new(:permalink => uri)
+  end
+  
+  def recommendations(limit = 20, order = "relevance", details = false, omit_feeds = nil)
+    sql = "SELECT recommendations.id, dest_entry_id, entries.permalink, entries.title, entries.description, entries.direct_link, feeds.short_title AS collection "
+    sql << ", relevance_calculated_at, relevance, clicks, avg_time_at_dest AS avg_time_on_target, author, published_at " if details == true
+    sql << "FROM recommendations "
+    sql << "INNER JOIN entries ON recommendations.dest_entry_id = entries.id "
+    sql << "INNER JOIN feeds ON entries.feed_id = feeds.id "
+    sql << "WHERE recommendations.entry_id = ? "
+    sql << ("AND entries.feed_id NOT IN (" + omit_feeds.gsub(/[^0-9,]/,'') + ") ") if omit_feeds != nil
+    sql << "ORDER BY " + order + " DESC "
+    sql << "LIMIT " + limit.to_s
+    Entry.find_by_sql([sql,self.id])
+  end
+
+  def recommendation_entries(limit = 20, order = "relevance", details = false, omit_feeds = nil)
+    sql = "SELECT recommendations.dest_entry_id AS id, entries.permalink, entries.title, entries.description, entries.direct_link, feeds.short_title AS collection "
+    sql << ", relevance_calculated_at, relevance, clicks, avg_time_at_dest AS avg_time_on_target, author, published_at " if details == true
+    sql << "FROM recommendations "
+    sql << "INNER JOIN entries ON recommendations.dest_entry_id = entries.id "
+    sql << "INNER JOIN feeds ON entries.feed_id = feeds.id "
+    sql << "WHERE recommendations.entry_id = ? "
+    sql << ("AND entries.feed_id NOT IN (" + omit_feeds.gsub(/[^0-9,]/,'') + ") ") if omit_feeds != nil
+    sql << "ORDER BY " + order + " DESC "
+    sql << "LIMIT " + limit.to_s
+    Entry.find_by_sql([sql,self.id])
+  end
+
+  def self.track_time_on_page(session, uri)
+    recommendation_id = session[:last_clicked_recommendation]
+    if !recommendation_id.nil?
+      time_on_page = (Time.now - session[:last_clicked_recommendation_time].to_f).to_i
+      
+      # if they spend longer than two minutes on a page, we don't infer anything
+      if time_on_page > 5 and time_on_page < 120
+        if normalized_uri(uri) != session[:last_clicked_recommendation_uri] 
+          recommendation = Recommendation.find(recommendation_id)
+          entry = Entry.find(recommendation.entry_id)
+          new_avg = (recommendation.avg_time_at_dest*recommendation.clicks - @@default_time_on_page + time_on_page)/recommendation.clicks
+          recommendation.avg_time_at_dest = new_avg
+          recommendation.save!
+          entry.rank_recommendations
+          session[:last_clicked_recommendation] = nil
+        end
+      else
+        session[:last_clicked_recommendation] = nil if time_on_page > 5
+      end
+    end
+  end
+  
+  def self.avg_time(clicks, old_avg, time_on_page)
+    return (old_avg*(clicks-1) + time_on_page)/clicks
+  end
+
+  def self.track_click(session, recommendation_id, referrer, redirect_type = "direct_link", requester = "unknown", user_agent = "unknown")
+    # look up the recommendation
+    recommendation = Recommendation.find(recommendation_id)
+    return "" if !recommendation
+    
+    # get the entries being linked from and to
+    entry = Entry.find(recommendation.entry_id)
+    target = Entry.find(recommendation.dest_entry_id)
+    
+    # get the list of recommendations that have been clicked during this session
+    clicks = session[:rids] || Array.new
+    
+    # redirect to our frame page
+    redirect = "/visits/#{recommendation.dest_entry_id}"
+    
+    # track the time on the last page
+    track_time_on_page(session, redirect)
+    
+    # if this is first time the user clicked on this recommendation during this session 
+    if !clicks.include?(recommendation_id)
+      
+      # add this recommendation to the end of the list 
+      clicks << recommendation_id
+      session[:rids] = clicks
+      
+      # update the click time
+      recommendation.avg_time_at_dest = ((recommendation.avg_time_at_dest*recommendation.clicks) + @@default_time_on_page)/(recommendation.clicks + 1) 
+      recommendation.clicks += 1 
+      recommendation.save!
+      
+      # store info about this click in the session
+      now = Time.now
+      session[:last_clicked_recommendation] = recommendation_id
+      session[:last_clicked_recommendation_time] = now
+      session[:last_clicked_recommendation_uri] = redirect
+
+      # update the recommendation cache for the entry
+      entry.rank_recommendations if entry
+      
+      # track the click in the db
+      Click.create(:recommendation_id => recommendation_id, :when => now, :referrer => referrer, :requester => requester, :user_agent => user_agent)
+    end
+    
+    return redirect   
+  end
+
+  def relevant_recommendations(limit = 5, order = "relevance", details = false, omit_feeds = nil)
+    return self.recommendations(limit, order, details, omit_feeds)
+  end
+
+  def self.truncate_words(text, length = 30, end_string = ' ...')
+    words = text.split()
+    words[0..(length-1)].join(' ') + (words.length > length ? end_string : '')
+  end
+  
+  def ranked_recommendations(limit = 5, order = "mixed", details = false, omit_feeds = nil)
+#    if self.id.nil?
+#      return Entry.real_time_recommendations(self.permalink, details, :core => 'en', :limit => limit)
+#    else
+      return relevant_recommendations(limit, "clicks DESC, relevance", details, omit_feeds) if order == "clicks" 
+      return relevant_recommendations(limit, "relevance", details, omit_feeds) if (order == "relevance" || details == true)
+      return relevant_recommendations_filtered(limit, details, omit_feeds) if omit_feeds != nil 
+#    end
+
+    recs = []
+    if self.popular != nil && !self.popular.empty?
+      recs.concat(ActiveSupport::JSON.decode(self.popular).first(limit))
+    end
+    if recs.length < limit && self.relevant != nil && !self.relevant.empty?
+      relevant_recs = randomize(ActiveSupport::JSON.decode(self.relevant))
+      recs.concat(relevant_recs.first(limit - recs.length))
+    end
+    if recs.length < limit && self.relevant != nil && !self.other.empty?
+      other_recs = randomize(ActiveSupport::JSON.decode(self.other))
+      recs.concat(other_recs.first(limit - recs.length))
+    end
+    return recs
+  end
+  
+  def relevant_recommendations_filtered(limit, details, omit_feeds)
+    # get recommendations for the entry from the recommendations table
+    recs = self.recommendations(limit, "mixed", details, omit_feeds)
+    
+    # for storing the various lists
+    popular_recs = []
+    relevant_recs = []
+    other_recs = []
+
+    # see where to cut draw the lines for popular and relevant
+    click_threshold = calc_click_threshold(recs)
+    relevance_threshold = calc_relevance_threshold(recs)
+    
+    # store the recommendations
+    recs.each do |r|
+      if (r["clicks"].to_i > click_threshold)
+        popular_recs << r 
+      elsif (r["relevance"].to_f > relevance_threshold)
+        relevant_recs << r
+      else 
+        other_recs << r
+      end
+    end
+    
+    # order popular items strictly by clicks
+    popular_recs.sort{|r1,r2| r2["avg_time_on_target"].to_i <=> r1["avg_time_on_target"].to_i}
+    
+    return popular_recs[0..limit] if popular_recs.size > limit 
+    return (popular_recs + relevant_recs)[0..limit] if (popular_recs.size + relevant_recs.size) > limit
+    return (popular_recs + relevant_recs + other_recs)[0..limit]
+  end
+
+  def json_recommendations(limit = 5, order = "mixed", details = false, omit_feeds = nil)
+    ActiveSupport::JSON.encode(ranked_recommendations(limit, order, details, omit_feeds))
+  end
+  
+  def rank_recommendations
+    return
+    # get recommendations for the entry from the recommendations table
+    recs = self.recommendations
+    
+    # for storing the various lists
+    popular_recs = []
+    relevant_recs = []
+    other_recs = []
+
+    # see where to cut draw the lines for popular and relevant
+    click_threshold = calc_click_threshold(recs)
+    relevance_threshold = calc_relevance_threshold(recs)
+    
+    # store the recommendations
+    recs.each do |r|
+      if (r["clicks"].to_i > click_threshold)
+        popular_recs << r 
+      elsif (r["relevance"].to_f > relevance_threshold)
+        relevant_recs << r
+      else 
+        other_recs << r
+      end
+    end
+    
+    # order popular items strictly by clicks
+    popular_recs.sort{|r1,r2| r2["avg_time_on_target"].to_i <=> r1["avg_time_on_target"].to_i}
+    
+    # cache the JSON for the lists in the entry record
+    self.popular = ActiveSupport::JSON.encode(popular_recs)
+    self.relevant = ActiveSupport::JSON.encode(relevant_recs)
+    self.other = ActiveSupport::JSON.encode(other_recs)
+    self.save!
+  end
+  
+  def randomize(recs)
+    i = recs.length
+    return recs if (i == 0)
+    while (i > 0)
+      i = i - 1
+      j = (rand*(i+1)).floor
+      ti = recs[i]
+      tj =recs[j]
+      recs[i] = tj
+      recs[j] = ti
+    end
+    return recs
+  end
+
+  def calc_relevance_threshold(recs)
+    sum = 0
+    recs.each do |r|
+      sum += r["relevance"].to_f
+    end
+    average = sum/recs.length
+    sum = 0
+    recs.each do |r|
+      sum += (r["relevance"].to_f-average)**2
+    end
+    standard_deviation = Math.sqrt(sum/recs.length);
+    return average + standard_deviation
+  end
+  
+  def calc_click_threshold(recs)
+    sum = 0
+    recs.each do |r|
+      sum += r["clicks"].to_f
+    end
+    average = sum/recs.length
+    sum = 0
+    recs.each do |r|
+      sum += (r["clicks"].to_f-average)**2
+    end
+    standard_deviation = Math.sqrt(sum/recs.length);
+    threshold = average + standard_deviation
+    return threshold > 5 ? threshold : 5
+  end
+  
+  protected
+  
+#  def self.redirect_uri(target, referrer, redirect_type)
+#    if !target.direct_link.nil? and redirect_type != "metadata"
+#      return target.direct_link if redirect_type == "direct_link" 
+#      if !referrer.nil?
+#        domain = "http://" + URI.parse(referrer).host
+#        return target.direct_link if target.permalink[0..domain.length-1] != domain
+#      end
+#    end
+#    return target.permalink
+#  end
+
+  def self.normalized_uri(uri)
+    uri.sub(/index.?\.(html|aspx|shtm|htm|asp|php|cfm|jsp|shtml|jhtml)$/, '')
+  end
+  
+  def self.real_time_recommendations(uri, details = false, options = {})
+    fields = "entries.id, entries.title, entries.permalink, entries.direct_link, feeds.short_title AS collection"
+    fields << ", entries.published_at, entries.description, entries.author" if details == true 
+    more_like_this(uri, options.merge(:select => fields, :joins => "INNER JOIN feeds ON feeds.id = entries.feed_id"))
+  end
+
+end