muck-services 0.1.2

data/app/models/feed.rb

@@ -0,0 +1,224 @@
+# == Schema Information
+#
+# Table name: feeds
+#
+#  id                         :integer(4)      not null, primary key
+#  uri                        :string(2083)
+#  display_uri                :string(2083)
+#  title                      :string(1000)
+#  short_title                :string(100)
+#  description                :text
+#  tag_filter                 :string(1000)
+#  top_tags                   :text
+#  priority                   :integer(4)      default(10)
+#  status                     :integer(4)      default(1)
+#  last_requested_at          :datetime        default(Wed Jan 01 00:00:00 UTC 1969)
+#  last_harvested_at          :datetime        default(Wed Jan 01 00:00:00 UTC 1969)
+#  harvest_interval           :integer(4)      default(86400)
+#  failed_requests            :integer(4)      default(0)
+#  error_message              :text
+#  service_id                 :integer(4)      default(0)
+#  login                      :string(255)
+#  password                   :string(255)
+#  created_at                 :datetime
+#  updated_at                 :datetime
+#  entries_changed_at         :datetime
+#  harvested_from_display_uri :string(2083)
+#  harvested_from_title       :string(1000)
+#  harvested_from_short_title :string(100)
+#  entries_count              :integer(4)
+#  default_language_id        :integer(4)      default(0)
+#  default_grain_size         :string(255)     default("unknown")
+#  contributor_id             :integer(4)
+#  etag                       :string(255)
+#
+
+class Feed < ActiveRecord::Base
+
+  include HTTParty
+  format :xml
+
+  validates_presence_of :uri
+
+  has_many :feed_parents
+  has_many :identity_feeds
+  has_many :aggregation_feeds
+  has_many :aggregations, :through => :aggregation_feeds
+  has_many :entries, :dependent => :destroy
+  belongs_to :contributor, :class_name => 'User', :foreign_key => 'contributor_id'
+  belongs_to :default_language, :class_name => 'Language', :foreign_key => 'default_language_id'
+  belongs_to :service
+  
+  named_scope :banned, :conditions => ["status = ?", MuckServices::Status::BANNED]
+  named_scope :valid, :conditions => "status >= 0", :include => [:default_language]
+  named_scope :by_title, :order => "title ASC", :include => [:default_language]
+  named_scope :recent, lambda { { :conditions => ['created_at > ?', 1.week.ago] } }
+  named_scope :by_newest, :order => "created_at DESC", :include => [:default_language]
+
+  attr_protected :status, :last_requested_at, :last_harvested_at, :harvest_interval, :failed_requests,
+                 :created_at, :updated_at, :entries_changed_at, :entries_count, :contributor_id
+  
+  # named_scope :ready_to_harvest, lambda { |*args| { :conditions => [ "feeds.last_harvested_at < ?", args.first || 1.day.ago.end_of_day ] } }
+
+  def banned?
+    self.status == MuckServices::Status::BANNED
+  end
+  
+  def pending?
+    self.status == MuckServices::Status::PENDING
+  end
+
+  def inform_admin
+    if GlobalConfig.inform_admin_of_global_feed && global?
+      ServicesMailer.deliver_notification_feed_added(self) # Global feed.  Email the admin to let them know a feed has been added
+    end
+  end
+  
+  # harvest_interval is stored in seconds
+  # default is 86400 which is one day
+  def harvest_interval_hours
+    self.harvest_interval/3600
+  end
+
+  # Converts hours into seconds for harvest_interval
+  def harvest_interval_hours=(interval)
+    self.harvest_interval = interval * 3600
+  end
+
+  def harvest
+    # check to see if the feed has changed
+    feed = Feedzirra::Feed.fetch_and_parse(self.uri)
+    feed.entries
+    # updated_feed = Feedzirra::Feed.update(self)
+    # if updated_feed.updated?
+    #   updated_feed.new_entries # get new entries
+    #   updated_feed.sanitize_entries! # clean up
+    # end
+  end
+
+  # provided to make feed quack like a feedzirra feed
+  def url
+    display_uri
+  end
+
+  # provided to make feed quack like a feedzirra feed
+  def feed_url
+    uri
+  end
+
+  # provided to make feed quack like a feedzirra feed
+  def last_modified
+    entries_changed_at
+  end
+  
+  # feeds that are not attached to anything become global to the site
+  def global?
+    self.feed_parents.empty? && self.identity_feeds.empty? && self.aggregations.empty?
+  end
+  
+  # Checks to see if there is a reference to the feed in any of the relation tables.
+  def in_use?
+    feed = FeedParent.find_by_feed_id(self.id)
+    return true if feed
+    feed = IdentityFeed.find_by_feed_id(self.id)
+    return true if feed
+    feed = AggregationFeed.find_by_feed_id(self.id)
+    return true if feed
+    false
+  end
+  
+  # This will delete a feed if there are no references to it
+  def delete_if_unused(user)
+    if user.id == contributor_id && !in_use?
+      self.destroy
+    else
+      false
+    end
+  end
+  
+  # Gathers all available feed uris from the given uri and parses them into
+  # feed objects
+  def self.gather_information(uri)
+    feeds = []
+    @available_feeds = discover_feeds(uri)
+    @available_feeds.each do |feed|
+      feeds << new_from_feedzirra(fetch_feed(feed.url)) unless feed.blank?
+    end
+    feeds
+  end
+
+  # Gathers all available feed uris from the given uri and parses them into
+  # feed objects
+  def self.feeds_from_uri(uri, user = nil)
+    feeds = []
+    @available_feeds = discover_feeds(uri)
+    @available_feeds.each do |feed|
+      feeds << create_from_feedzirra(fetch_feed(feed.url), user) unless feed.blank?
+    end
+    feeds
+  end
+  
+  # Fetch a remote feed
+  def self.fetch_feed(url)
+    return nil if url.blank?
+    Feedzirra::Feed.fetch_and_parse(url)
+  end
+  
+  # Turns a feed from feedzirra into a muck feed
+  def self.new_from_feedzirra(feed)
+    return if feed.blank?
+    Feed.new(:short_title => feed.title,
+             :title => feed.title,
+             :display_uri => feed.url,
+             :uri => feed.feed_url)
+  end
+
+  # Creates a feed from feedzirra into a muck feed
+  def self.create_from_feedzirra(feed, user)
+    return if feed.blank?
+    Feed.find_or_create(feed.feed_url, feed.title, '', '', Service.find_service_by_uri(feed.url), user, feed.url)
+  end
+  
+  # Looks for feeds from a given url
+  def self.discover_feeds(uri)
+    Feedbag.find(uri)
+  end
+  
+  # Finds or creates a feed based on the url.  Any give feed uri should only exist once in the system
+  def self.find_or_create(uri, title, username, password, service_id, contributor_id, display_uri = nil)
+    Feed.find_by_uri(uri) ||
+      Feed.create(:uri => uri,
+                 :harvest_interval => '01:00:00',
+                 :last_harvested_at => Time.at(0),
+                 :title => title,
+                 :login => username,
+                 :password => password,
+                 :service_id => service_id,
+                 :contributor_id => contributor_id,
+                 :display_uri => display_uri)
+  end
+  
+  # Create feeds for the given uris
+  # user: User that will be set as the feed contributor
+  # uris: An array of uris for which to create feeds
+  # service: A default service to be associated with all the feeds.
+  def self.create_tag_feeds(user = nil, uris = nil, service = nil)
+    return [] if uris.blank?
+    service ||= Service.default_service
+    uris.collect { |uri| Feed.find_or_create(uri, '', '', '', service.id, user, uri) }
+  end
+  
+  # Combines entries in a collection of feeds together and sorts the entries by date
+  def self.combine_sort(feeds)
+    return [] if feeds.nil? || feeds.blank?
+    entries = feeds.collect{|feed| feed.entries}.flatten!
+    sort_entries(entries)
+  end
+  
+  # Sorts a collection of entries by date
+  def self.sort_entries(entries)
+    return [] if entries.nil? || entries.blank?
+    entries.sort { |a,b| b.published_at <=> a.published_at }
+  end
+
+end

data/app/models/feed_parent.rb

@@ -0,0 +1,18 @@
+# == Schema Information
+#
+# Table name: feed_parents
+#
+#  id           :integer(4)      not null, primary key
+#  feed_id      :integer(4)
+#  ownable_id   :integer(4)
+#  ownable_type :string(255)
+#  created_at   :datetime
+#  updated_at   :datetime
+#
+
+class FeedParent < ActiveRecord::Base
+  unloadable
+  
+  belongs_to :feed
+  belongs_to :ownable, :polymorphic => true
+end

data/app/models/identity_feed.rb

@@ -0,0 +1,26 @@
+# == Schema Information
+#
+# Table name: identity_feeds
+#
+#  id           :integer(4)      not null, primary key
+#  feed_id      :integer(4)      not null
+#  ownable_id   :integer(4)      not null
+#  ownable_type :string(255)     not null
+#
+
+class IdentityFeed < ActiveRecord::Base
+  belongs_to :ownable, :polymorphic => true
+  belongs_to :feed
+  
+  validates_uniqueness_of :feed_id, :scope => [:ownable_id, :ownable_type]
+  
+  # Determines whether or not he given user can edit the identity feed
+  def can_edit?(user)
+    if ownable == user || user.admin?
+      true
+    else
+      false
+    end
+  end
+  
+end

data/app/models/oai_endpoint.rb

@@ -0,0 +1,39 @@
+# == Schema Information
+#
+# Table name: oai_endpoints
+#
+#  id              :integer(4)      not null, primary key
+#  uri             :string(2083)
+#  display_uri     :string(2083)
+#  metadata_prefix :string(255)
+#  title           :string(1000)
+#  short_title     :string(100)
+#
+class OaiEndpoint < ActiveRecord::Base
+  
+  belongs_to :contributor, :class_name => 'User', :foreign_key => 'contributor_id'
+  belongs_to :default_language, :class_name => 'Language', :foreign_key => 'default_language_id'
+  
+  validates_presence_of :uri
+  
+  named_scope :banned, :conditions => "status < 0"
+  named_scope :valid, :conditions => "status >= 0"
+  named_scope :by_title, :order => "title ASC"
+  named_scope :recent, lambda { { :conditions => ['created_at > ?', 1.week.ago] } }
+  named_scope :by_newest, :order => "created_at DESC", :include => [:default_language]
+  
+  attr_protected :status, :contributor_id
+  
+  def banned?
+    self.status == MuckServices::Status::BANNED
+  end
+
+  def pending?
+    self.status == MuckServices::Status::PENDING
+  end
+
+  def inform_admin
+    ServicesMailer.deliver_notification_feed_added(self)
+  end
+  
+end

data/app/models/recommendation.rb

@@ -0,0 +1,15 @@
+# == Schema Information
+#
+# Table name: recommendations
+#
+#  id               :integer(4)      not null, primary key
+#  entry_id         :integer(4)
+#  dest_entry_id    :integer(4)
+#  rank             :integer(4)
+#  relevance        :decimal(8, 6)   default(0.0)
+#  clicks           :integer(4)      default(0)
+#  avg_time_at_dest :integer(4)      default(60)
+#
+
+class Recommendation < ActiveRecord::Base
+end

data/app/models/service.rb

@@ -0,0 +1,486 @@
+# == Schema Information
+#
+# Table name: services
+#
+#  id                  :integer(4)      not null, primary key
+#  uri                 :string(2083)    default("")
+#  name                :string(1000)    default("")
+#  api_uri             :string(2083)    default("")
+#  uri_template        :string(2083)    default("")
+#  icon                :string(2083)    default("rss.gif")
+#  sort                :integer(4)
+#  requires_password   :boolean(1)
+#  use_for             :string(255)
+#  service_category_id :integer(4)
+#  active              :boolean(1)      default(TRUE)
+#  prompt              :string(255)
+#  template            :string(255)
+#
+
+class Service < ActiveRecord::Base
+  
+  belongs_to :service_category
+  named_scope :sorted_id, :order => "id ASC"
+  named_scope :sorted, :order => "sort ASC"
+  named_scope :identity_services, :conditions => ['use_for = ?', 'identity']
+  named_scope :tag_services, :conditions => ['use_for = ?', 'tags']
+  named_scope :photo_services, :conditions => ["service_categories.id = services.service_category_id AND service_categories.name = 'Photos'"], :include => ['service_category']
+
+  # Indicates whether service is primarily a photo service ie from flick, picasa, etc
+  #
+  # refresh_services:   Optional parameter indicating whether or not to reload values from the database before checking service type
+  def photo?(refresh_services = false)
+    Service.get_photo_services(refresh_services).include?(self)
+  end
+  
+  # Indicates whether service is primarily a video service ie from youtube, etc
+  #
+  # refresh_services:   Optional parameter indicating whether or not to reload values from the database before checking service type
+  def video?(refresh_services = false)
+    Service.get_video_services(refresh_services).include?(self)
+  end
+  
+  # Indicates whether service is primarily a bookmark service ie delicious, etc
+  #
+  # refresh_services:   Optional parameter indicating whether or not to reload values from the database before checking service type
+  def bookmark?(refresh_services = false)
+    Service.get_bookmark_services(refresh_services).include?(self)
+  end
+  
+  # Indicates whether service is primarily music
+  #
+  # refresh_services:   Optional parameter indicating whether or not to reload values from the database before checking service type
+  def music?(refresh_services = false)
+    Service.get_music_services(refresh_services).include?(self)
+  end
+  
+  # Indicates whether service is primarily news
+  #
+  # refresh_services:   Optional parameter indicating whether or not to reload values from the database before checking service type
+  def news?(refresh_services = false)
+    Service.get_news_services(refresh_services).include?(self)
+  end
+  
+  # Indicates whether service is primarily blog related
+  #
+  # refresh_services:   Optional parameter indicating whether or not to reload values from the database before checking service type
+  def blog?(refresh_services = false)
+    Service.get_blog_services(refresh_services).include?(self)
+  end
+  
+  # Indicates whether service is primarily search related
+  #
+  # refresh_services:   Optional parameter indicating whether or not to reload values from the database before checking service type
+  def search?(refresh_services = false)
+    Service.get_search_services(refresh_services).include?(self)
+  end
+  
+  # Indicates whether service is general (ie not video, photo, music or bookmark)
+  #
+  # refresh_services:   Optional parameter indicating whether or not to reload values from the database before checking service type
+  def general?(refresh_services = false)
+    Service.get_general_services(refresh_services).include?(self)
+  end
+  
+  def human_uri(tag)
+    generate_tag_template_uri(tag, self.uri_template)
+  end
+  
+  # Generate a uri for the current service
+  def generate_tag_uri(tag)
+    generate_tag_template_uri(tag, self.uri_data_template)
+  end
+  
+  def generate_tag_template_uri(tag, uri_template)
+    if self.name == 'Flickr'
+      uri_template.sub("{tag}", tag.gsub('+',',')) # flickr wants a comma deliminated list of tags
+    else
+      uri_template.sub("{tag}", tag)
+    end
+  end
+  
+  # Requires settings in global_config.yml
+  # For example:
+  # amazon_access_key_id: 'some key from your account'
+  # amazon_secret_access_key: 'the secret from your account'
+  # amazon_associate_tag: 'optional'
+  # ecs_to_rss_wishlist: "http://www.example.com/ecs_to_rss-wishlist.xslt"
+  def generate_uris(username = '', password = '', uri = '')
+    if self.name == 'Facebook'
+      # Facebook can't just use feeds like everyone else.
+      params = {}
+      pairs = uri.split('?')[1].split('&')
+      pairs.each do |pair|
+        p = pair.split('=')
+        params[p[0].to_sym] = p[1]
+      end
+      uris = []
+      uris << OpenStruct.new(:url => "http://www.facebook.com/feeds/notifications.php?id=#{params[:id]}&viewer=#{params[:id]}&key=#{params[:key]}&format=rss20", :title => I18n.t('muck.services.facebook_notifications'))
+      uris << OpenStruct.new(:url => "http://www.facebook.com/feeds/share_posts.php?id=#{params[:id]}&viewer=#{params[:id]}&key=#{params[:key]}&format=rss20", :title => I18n.t('muck.services.facebook_shares'))
+      uris << OpenStruct.new(:url => "http://www.facebook.com/feeds/notes.php?id=#{params[:id]}&viewer=#{params[:id]}&key=#{params[:key]}&format=rss20", :title => I18n.t('muck.services.facebook_notes'))
+      uris
+    elsif self.name == 'Amazon'
+      return [] if username.blank?
+      # Have to build and sign Amazon wishlist rss feeds
+      am = AmazonRequest.new(GlobalConfig.amazon_access_key_id, GlobalConfig.amazon_secret_access_key, GlobalConfig.ecs_to_rss_wishlist, GlobalConfig.amazon_associate_tag)
+      results = am.get_amazon_feeds(username) # username needs to be the user's Amazon email
+      results.collect { |result| OpenStruct.new(:url => result, :title => 'Amazon Wishlist') }
+    elsif !self.uri_data_template.blank? && !username.blank?
+      return [] if username.blank?
+      uri = self.uri_data_template.sub("{username}", username)
+      Feed.discover_feeds(uri)
+    elsif !uri.blank?
+      return [] if uri.blank?
+      Feed.discover_feeds(uri)
+    end
+  end
+  
+  # Generates uris for 'tag' using all services where 'use_for' is 'tags'
+  def self.generate_tag_uris(terms, selected_service_ids = nil)
+    split_terms(terms).collect { |tag|
+      get_tag_services(selected_service_ids).collect { |service| service.generate_tag_uri(tag) }
+    }.flatten!
+  end
+
+  # creates a feed for a service with a username and optional password
+  def self.create_tag_feeds_for_service(service, uri, username, password, contributor)
+    uris = service.generate_uris(username, password, uri)
+    uris.collect{ |u| Feed.find_or_create(u.url, u.title, username, password, service.id, contributor) } if uris
+  end
+
+
+
+  def self.build_photo_feeds(terms, user, service_ids = nil, refresh_services = false)
+    if service_ids.nil?
+      service_ids = get_photo_tag_services(refresh_services).map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_photo_tag_services(refresh_services).map(&:id)
+    end
+    build_tag_feeds(terms, user, service_ids, refresh_services)
+  end
+  
+  def self.build_video_feeds(terms, user, service_ids = nil, refresh_services = false)
+    if service_ids.nil?
+      service_ids = get_video_tag_services(refresh_services).map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_video_tag_services(refresh_services).map(&:id)
+    end
+    build_tag_feeds(terms, user, service_ids, refresh_services)
+  end
+  
+  def self.build_bookmark_feeds(terms, user, service_ids = nil, refresh_services = false)
+    if service_ids.nil?
+      service_ids = get_bookmark_tag_services(refresh_services).map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_bookmark_tag_services(refresh_services).map(&:id)
+    end
+    build_tag_feeds(terms, user, service_ids, refresh_services)
+  end
+  
+  def self.build_music_feeds(terms, user, service_ids = nil, refresh_services = false)
+    if service_ids.nil?
+      service_ids = get_music_tag_services(refresh_services).map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_music_tag_services(refresh_services).map(&:id)
+    end
+    build_tag_feeds(terms, user, service_ids, refresh_services)
+  end
+  
+  def self.build_news_feeds(terms, user, service_ids = nil, refresh_services = false)
+    if service_ids.nil?
+      service_ids = get_news_tag_services(refresh_services).map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_news_tag_services(refresh_services).map(&:id)
+    end
+    build_tag_feeds(terms, user, service_ids, refresh_services)
+  end
+  
+  def self.build_blog_feeds(terms, user, service_ids = nil, refresh_services = false)
+    if service_ids.nil?
+      service_ids = get_blog_tag_services(refresh_services).map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_blog_tag_services(refresh_services).map(&:id)
+    end
+    build_tag_feeds(terms, user, service_ids, refresh_services)
+  end
+  
+  def self.build_search_feeds(terms, user, service_ids = nil, refresh_services = false)
+    if service_ids.nil?
+      service_ids = get_search_tag_services(refresh_services).map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_search_tag_services(refresh_services).map(&:id)
+    end
+    build_tag_feeds(terms, user, service_ids, refresh_services)
+  end
+  
+  def self.build_general_feeds(terms, user, service_ids = nil, refresh_services = false)
+    if service_ids.nil?
+      service_ids = get_general_tag_services(refresh_services).map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_general_tag_services(refresh_services).map(&:id)
+    end
+    build_tag_feeds(terms, user, service_ids, refresh_services)
+  end
+  
+  
+  
+  # Get all photo services
+  #
+  # 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 self.get_photo_services(refresh_services = false)
+    @photo_services = nil if refresh_services
+    @photo_services ||= get_services(refresh_services).find_all{|service| service.service_category.name == 'Photos' }
+  end
+  
+  # Get all video services
+  #
+  # 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 self.get_video_services(refresh_services = false)
+    @video_services = nil if refresh_services
+    @video_services ||= get_services(refresh_services).find_all{|service| service.service_category.name == 'Videos' }
+  end
+  
+  # Get all bookmark services
+  #
+  # 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 self.get_bookmark_services(refresh_services = false)
+    @bookmark_services = nil if refresh_services
+    @bookmark_services ||= get_services(refresh_services).find_all{|service| service.service_category.name == 'Bookmarks' }
+  end
+  
+  # Get all music services
+  #
+  # 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 self.get_music_services(refresh_services = false)
+    @music_services = nil if refresh_services
+    @music_services ||= get_services(refresh_services).find_all{|service| service.service_category.name == 'Music' }
+  end
+
+  # Get all news services
+  #
+  # 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 self.get_news_services(refresh_services = false)
+    @news_services = nil if refresh_services
+    @news_services ||= get_services(refresh_services).find_all{|service| service.service_category.name == 'News' }
+  end
+  
+  # Get all blog services
+  #
+  # 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 self.get_blog_services(refresh_services = false)
+    @blog_services = nil if refresh_services
+    @blog_services ||= get_services(refresh_services).find_all{|service| service.service_category.name == 'Blogging' }
+  end
+  
+  # Get all search services
+  #
+  # 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 self.get_search_services(refresh_services = false)
+    @search_services = nil if refresh_services
+    @search_services ||= get_services(refresh_services).find_all{|service| service.service_category.name == 'Search' }
+  end
+  
+  # Get all general services. These are all services except photo, video, bookmark and music.
+  #
+  # 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 self.get_general_services(refresh_services = false)
+    @general_services = nil if refresh_services
+    @general_services ||= get_services(refresh_services).find_all{|service| !non_general_categories.include?(service.service_category.name) }
+  end
+  
+  
+  
+  # Get all photo services that are used to generate tag feeds
+  #
+  # 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 self.get_photo_tag_services(refresh_services = false)
+    @photo_services = nil if refresh_services
+    @photo_services ||= get_tag_services(nil, refresh_services).find_all{|service| service.service_category.name == 'Photos' }
+  end
+
+  # Get all video services that are used to generate tag feeds
+  #
+  # 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 self.get_video_tag_services(refresh_services = false)
+    @video_services = nil if refresh_services
+    @video_services ||= get_tag_services(nil, refresh_services).find_all{|service| service.service_category.name == 'Videos' }
+  end
+  
+  # Get all bookmark services that are used to generate tag feeds
+  #
+  # 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 self.get_bookmark_tag_services(refresh_services = false)
+    @bookmark_services = nil if refresh_services
+    @bookmark_services ||= get_tag_services(nil, refresh_services).find_all{|service| service.service_category.name == 'Bookmarks' }
+  end
+  
+  # Get all music services that are used to generate tag feeds
+  #
+  # 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 self.get_music_tag_services(refresh_services = false)
+    @music_services = nil if refresh_services
+    @music_services ||= get_tag_services(nil, refresh_services).find_all{|service| service.service_category.name == 'Music' }
+  end
+  
+  # Get all news services that are used to generate tag feeds
+  #
+  # 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 self.get_news_tag_services(refresh_services = false)
+    @news_services = nil if refresh_services
+    @news_services ||= get_tag_services(nil, refresh_services).find_all{|service| service.service_category.name == 'News' }
+  end
+  
+  # Get all blog services that are used to generate tag feeds
+  #
+  # 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 self.get_blog_tag_services(refresh_services = false)
+    @blog_services = nil if refresh_services
+    @blog_services ||= get_tag_services(nil, refresh_services).find_all{|service| service.service_category.name == 'Blogging' }
+  end
+  
+  # Get all search services that are used to generate tag feeds
+  #
+  # 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 self.get_search_tag_services(refresh_services = false)
+    @search_services = nil if refresh_services
+    @search_services ||= get_tag_services(nil, refresh_services).find_all{|service| service.service_category.name == 'Search' }
+  end
+  
+  # Get all general services that are used to generate tag feeds
+  #
+  # 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 self.get_general_tag_services(refresh_services = false)
+    @general_services = nil if refresh_services
+    @general_services ||= get_tag_services(nil, refresh_services).find_all{|service| !non_general_categories.include?(service.service_category.name) }
+  end
+  
+  
+  
+  
+  # Builds tag based feeds for the given term.  Feeds are not saved to the database. 
+  #
+  # terms:                Terms for which to generate feeds.  This value can be an array, a single string, 
+  #                       or a list of items seperated by a comma.
+  # user:                 User to attach the feed to.  This is the feed 'contributor.
+  # selected_service_ids: ids for services to select.
+  # 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 self.build_tag_feeds(terms, user, selected_service_ids = nil, refresh_services = false)
+    services = get_tag_services(selected_service_ids, refresh_services)
+    split_terms(terms).collect { |tag|
+      services.collect { |service| Feed.new(:uri => service.generate_tag_uri(tag),
+                                            :display_uri => service.human_uri(tag),
+                                            :title => I18n.t('muck.services.service_feed_name', :term => CGI.unescape(tag).humanize, :service => service.name),
+                                            :service_id => service.id,
+                                            :contributor_id => user) }
+    }.flatten!
+  end
+  
+  # Builds feeds (does not save them to the db) for the given term.  Note that this
+  # method calls the url for each feed created to attempt auto discovery and so it 
+  # can take a while to run.
+  #
+  # terms:                Terms for which to generate feeds.  This value can be an array, a single string, 
+  #                       or a list of items seperated by a comma.
+  # user:                 User to attach the feed to.  This is the feed 'contributor.
+  # selected_service_ids: ids for services to select.
+  def self.build_live_tag_feeds(terms, user, selected_service_ids = nil)
+    uris = generate_tag_uris(terms, selected_service_ids)
+    feed_uris = uris.collect { |uri| Feed.discover_feeds(uri)}
+    feed_uris.collect { |feed| Feed.new(:uri => feed.url,
+                                        :title => feed.title,
+                                        :service_id => service.id,
+                                        :contributor_id => user) }
+  end
+  
+  # Create feeds for the given terms and save them to the database.
+  # terms:                Terms for which to generate feeds.  This value can be an array, a single string,
+  #                       or a list of items seperated by a comma.
+  # user:                 User to attach the feed to.  This is the feed 'contributor.
+  # selected_service_ids: ids for services to select.
+  # 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 self.create_tag_feeds(terms, user = nil, selected_service_ids = nil, refresh_services = false)
+    services = get_tag_services(selected_service_ids, refresh_services)
+    split_terms(terms).collect { |tag|
+      services.collect { |service| Feed.find_or_create(service.generate_tag_uri(tag), tag, '', '', service.id, user, service.human_uri(tag)) }
+    }.flatten!
+  end
+  
+  # Splits terms using a comma.  This method also URI encodes all resulting terms
+  # terms:                A string, array or comma delimited string of terms (tags).
+  def self.split_terms(terms)
+    return '' if terms.blank?
+    terms = terms.split(',') unless terms.is_a?(Array)
+    terms.collect { |tag| CGI.escape(tag.strip) }
+  end
+  
+  # Gets all services with the specified service ids.  If selected_service_ids is not 
+  # provided then this method will get all tag services 
+  #
+  # selected_service_ids: ids for services to select.
+  # 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 self.get_tag_services(selected_service_ids = nil, refresh_services = false)
+    if selected_service_ids
+      selected_service_ids.collect! { |service_id| service_id.to_i } # make sure the ids are ints
+      Service.tag_services.find_all { |service| selected_service_ids.include?(service.id) }
+    else
+      if refresh_services
+        @tag_services = Service.tag_services
+      else
+        @tag_services ||= Service.tag_services
+      end
+    end
+  end
+  
+  # Selects and caches all services from the database.
+  # 
+  # 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 self.get_services(refresh_services = false)
+    @all_services = nil if refresh_services
+    @all_services ||= Service.all
+  end
+  
+  # Attempts to find a service object using a uri
+  #
+  # uri:              Uri to search for.  This method will attempt to all services for any part of the provided uri.
+  # refresh_services: Forces a refresh of the services.  By default the services are cached for the duration of the request.
+  def self.find_service_by_uri(uri, refresh_services = false)
+    service = get_services(refresh_services).detect { |service| service.uri && service.uri.length > 0 && (uri.include?(service.uri) || service.uri.include?(uri)) }
+    service ||= default_service
+    service
+  end
+  
+  # Turns all items in an array into integers.
+  def self.make_int_array(a)
+    a.collect{|i| i.to_i}
+  end
+  
+  # Default service is RSS
+  def self.default_service
+    Service.find_by_name('rss') # this will return the default rss service
+  end
+  
+  def self.non_general_categories
+    ['Photos', 'Videos', 'Bookmarks', 'Music', 'News', 'Blogging', 'Search']
+  end
+  
+end