Class: Feed

Inherits:
ActiveRecord::Base
  • Object
show all
Includes:
HTTParty
Defined in:
app/models/feed.rb

Overview

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 Method Summary collapse

Instance Method Summary collapse

Class Method Details

.combine_sort(feeds) ⇒ Object

Combines entries in a collection of feeds together and sorts the entries by date



212
213
214
215
216
 
# File 'app/models/feed.rb', line 212

def self.combine_sort(feeds)
  return [] if feeds.nil? || feeds.blank?
  entries = feeds.collect{|feed| feed.entries}.flatten!
  sort_entries(entries)
end

.create_from_feedzirra(feed, user) ⇒ Object

Creates a feed from feedzirra into a muck feed



177
178
179
180
 
# File 'app/models/feed.rb', line 177

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

.create_tag_feeds(user = nil, uris = nil, service = nil) ⇒ Object

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.



205
206
207
208
209
 
# File 'app/models/feed.rb', line 205

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

.discover_feeds(uri) ⇒ Object

Looks for feeds from a given url



183
184
185
 
# File 'app/models/feed.rb', line 183

def self.discover_feeds(uri)
  Feedbag.find(uri)
end

.feeds_from_uri(uri, user = nil) ⇒ Object

Gathers all available feed uris from the given uri and parses them into feed objects



152
153
154
155
156
157
158
159
 
# File 'app/models/feed.rb', line 152

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_feed(url) ⇒ Object

Fetch a remote feed



162
163
164
165
 
# File 'app/models/feed.rb', line 162

def self.fetch_feed(url)
  return nil if url.blank?
  Feedzirra::Feed.fetch_and_parse(url)
end

.find_or_create(uri, title, username, password, service_id, contributor_id, display_uri = nil) ⇒ Object

Finds or creates a feed based on the url. Any give feed uri should only exist once in the system



188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'app/models/feed.rb', line 188

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

.gather_information(uri) ⇒ Object

Gathers all available feed uris from the given uri and parses them into feed objects



141
142
143
144
145
146
147
148
 
# File 'app/models/feed.rb', line 141

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

.new_from_feedzirra(feed) ⇒ Object

Turns a feed from feedzirra into a muck feed



168
169
170
171
172
173
174
 
# File 'app/models/feed.rb', line 168

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

.sort_entries(entries) ⇒ Object

Sorts a collection of entries by date



219
220
221
222
 
# File 'app/models/feed.rb', line 219

def self.sort_entries(entries)
  return [] if entries.nil? || entries.blank?
  entries.sort { |a,b| b.published_at <=> a.published_at }
end

Instance Method Details

#banned? ⇒ Boolean

named_scope :ready_to_harvest, lambda { |*args| { :conditions => [ “feeds.last_harvested_at < ?”, args.first || 1.day.ago.end_of_day ] } }

Returns:

  • (Boolean) 


63
64
65
 
# File 'app/models/feed.rb', line 63

def banned?
  self.status == MuckRaker::Status::BANNED
end

#delete_if_unused(user) ⇒ Object

This will delete a feed if there are no references to it



131
132
133
134
135
136
137
 
# File 'app/models/feed.rb', line 131

def delete_if_unused(user)
  if user.id == contributor_id && !in_use?
    self.destroy
  else
    false
  end
end

#feed_url ⇒ Object

provided to make feed quack like a feedzirra feed



105
106
107
 
# File 'app/models/feed.rb', line 105

def feed_url
  uri
end

#global? ⇒ Boolean

feeds that are not attached to anything become global to the site

Returns:

  • (Boolean) 


115
116
117
 
# File 'app/models/feed.rb', line 115

def global?
  self.feed_parents.empty? && self.identity_feeds.empty? && self.aggregations.empty?
end

#harvest ⇒ Object 



88
89
90
91
92
93
94
95
96
97
 
# File 'app/models/feed.rb', line 88

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

#harvest_interval_hours ⇒ Object

harvest_interval is stored in seconds default is 86400 which is one day



79
80
81
 
# File 'app/models/feed.rb', line 79

def harvest_interval_hours
  self.harvest_interval/3600
end

#harvest_interval_hours=(interval) ⇒ Object

Converts hours into seconds for harvest_interval



84
85
86
 
# File 'app/models/feed.rb', line 84

def harvest_interval_hours=(interval)
  self.harvest_interval = interval * 3600
end

#in_use? ⇒ Boolean

Checks to see if there is a reference to the feed in any of the relation tables.

Returns:

  • (Boolean) 


120
121
122
123
124
125
126
127
128
 
# File 'app/models/feed.rb', line 120

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

#inform_admin ⇒ Object 



71
72
73
74
75
 
# File 'app/models/feed.rb', line 71

def inform_admin
  if GlobalConfig.inform_admin_of_global_feed && global?
    RakerMailer.deliver_notification_feed_added(self) # Global feed.  Email the admin to let them know a feed has been added
  end
end

#last_modified ⇒ Object

provided to make feed quack like a feedzirra feed



110
111
112
 
# File 'app/models/feed.rb', line 110

def last_modified
  entries_changed_at
end

#pending? ⇒ Boolean

Returns:

  • (Boolean) 


67
68
69
 
# File 'app/models/feed.rb', line 67

def pending?
  self.status == MuckRaker::Status::PENDING
end

#url ⇒ Object

provided to make feed quack like a feedzirra feed



100
101
102
 
# File 'app/models/feed.rb', line 100

def url
  display_uri
end