harvester 0.8.0.pre.1

data/lib/harvester/generate.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+require_relative '../harvester'
+require_relative 'generator/link_absolutizer'
+require_relative 'generator/entity_translator'
+
+require 'fileutils'
+require 'time'
+require 'rexml/document'
+begin
+  require 'xml/xslt'
+rescue LoadError
+  require 'xml/libxslt'
+end
+
+class Harvester
+  module GENERATE; end
+
+  # generates the static html/feed files
+  def generate!
+    info "GENERATE"
+
+    f        = Generator.new @dbi, @logger
+    xslt     = XML::XSLT.new
+    xslt.xml = f.generate_root.to_s
+
+    default_template_dir = File.dirname(__FILE__) + '/../../data/templates'
+    template_dir = @settings['templates'] || default_template_dir
+    output_dir   = @settings['output']
+
+    task "copy static files" do
+      FileUtils.mkdir_p output_dir
+      FileUtils.cp_r Dir[File.join( template_dir, 'static', '*' )], output_dir
+    end
+
+    begin
+      Dir.foreach(template_dir) { |template_file|
+        next if template_file =~ /^\./ || template_file == 'static'
+
+        task "process #{template_file}" do
+          xslt.xsl = File.join( template_dir, template_file )
+          File::open( File.join( output_dir, template_file ), 'w') { |f| f.write(xslt.serve) }
+        end
+      }
+    rescue Errno::ENOENT
+      warn "Couldn't find templates directory, fallback to default templates!"
+      template_dir = default_template_dir
+      retry
+    end
+  end
+end
+
+# generates the static html/feed files
+class Harvester::Generator
+  FUNC_NAMESPACE = 'http://astroblog.spaceboyz.net/harvester/xslt-functions'
+
+  def initialize(dbi, logger)
+    @dbi = dbi
+    @logger = logger
+    %w(collection-items feed-items item-description item-images item-enclosures).each { |func|
+      XML::XSLT.extFunction(func, FUNC_NAMESPACE, self)
+    }
+  end
+
+  def generate_root
+    root = REXML::Element.new('collections')
+    @dbi.execute("SELECT collection FROM sources GROUP BY collection").each{ |name,|
+      collection = root.add(REXML::Element.new('collection'))
+      collection.attributes['name'] = name
+      @dbi.execute("SELECT rss,title,link,description FROM sources WHERE collection=?", name).each{ |rss,title,link,description|
+        #p [title, description]
+        feed = collection.add(REXML::Element.new('feed'))
+        feed.add(REXML::Element.new('rss')).text = rss
+        feed.add(REXML::Element.new('title')).text = title
+        feed.add(REXML::Element.new('link')).text = link
+        feed.add(REXML::Element.new('description')).text = description
+      }
+    }
+
+    EntityTranslator.run(root, true, @logger)
+  end
+
+  def collection_items(collection, max=23)
+    items = REXML::Element.new('items')
+    @dbi.execute("SELECT items.title,items.date,items.link,items.rss FROM items,sources WHERE items.rss=sources.rss AND sources.collection LIKE ? ORDER BY items.date DESC LIMIT ?", collection, max.to_i).each{ |title,date,link,rss|
+      if title # TODO: debug (sqlite)
+        item = items.add(REXML::Element.new('item'))
+        item.add(REXML::Element.new('title')).text = title
+        item.add(REXML::Element.new('date')).text = Time.parse(date).xmlschema
+        item.add(REXML::Element.new('link')).text = link
+        item.add(REXML::Element.new('rss')).text = rss
+      end
+    }
+
+    EntityTranslator.run(items, true, @logger)
+  end
+
+  def feed_items(rss, max=23)
+    items = REXML::Element.new('items')
+    @dbi.execute("SELECT title,date,link FROM items WHERE rss=? ORDER BY date DESC LIMIT ?", rss, max.to_i).each{ |title,date,link| #p rss,title,date,link
+      # p title
+      if title # TODO: debug (sqlite)
+        item = items.add(REXML::Element.new('item'))
+        item.add(REXML::Element.new('title')).text = title
+        item.add(REXML::Element.new('date')).text = Time.parse(date).xmlschema
+        item.add(REXML::Element.new('link')).text = link
+      end
+    }
+
+    EntityTranslator.run(items, true, @logger)
+  end
+
+  def item_description(rss, item_link)
+    # FIXME!!!! tmp ugly sqlite fix
+    if @dbi.driver.class.to_s =~ /sqlite3/i
+    a= "SELECT description FROM items WHERE rss='%s' AND link='%s'" % [rss, item_link].map{|e|::SQLite3::Database.quote(e) }
+    b= @dbi.execute(a).fetch
+    else
+    b= @dbi.execute("SELECT description FROM items WHERE rss=? AND link=?", rss, item_link).fetch
+    end
+    b.each{ |desc,|
+      desc = EntityTranslator.run(desc, false, @logger)
+      desc = LinkAbsolutizer.run(desc, item_link, @logger)
+      return desc
+    }
+    ''
+  end
+
+  def item_images(rss, item_link)
+    desc = "<description>" + item_description(rss, item_link) + "</description>"
+    images = REXML::Element.new('images')
+    REXML::Document.new(desc.to_s).root.each_element('//img') { |img|
+      images.add img
+    }
+    mages
+  end
+
+  def item_enclosures(rss, link)
+    #p [rss,link]
+    enclosures = REXML::Element.new('enclosures')
+    @dbi.execute("SELECT href, mime, title, length FROM enclosures WHERE rss=? AND link=? ORDER BY length DESC", rss, link).each{ |href,mime,title,length|
+      enclosure = enclosures.add(REXML::Element.new('enclosure'))
+      enclosure.add(REXML::Element.new('href')).text = href
+      enclosure.add(REXML::Element.new('mime')).text = mime
+      enclosure.add(REXML::Element.new('title')).text = title
+      enclosure.add(REXML::Element.new('length')).text = length
+    }
+    #p enclosures.to_s
+    enclosures
+  end
+end
+

data/lib/harvester/generator/entity_translator.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+class Harvester; class Generator; end; end
+
+# This module translates old-fashioned entities into utf-8
+class Harvester::Generator::EntityTranslator
+  def self.run(doc, with_xmldecl = true, logger = nil)
+    logger ||= Logger.new(STDOUT)
+
+    @entities = {}
+    %w(HTMLlat1.ent HTMLsymbol.ent HTMLspecial.ent).each do |file|
+      begin
+        load_entities_from_file(
+          File.expand_path( File.dirname(__FILE__) + '/../../../data/ent/' + file )
+        )
+      #rescue Errno::ENOENT
+      #  system("wget http://www.w3.org/TR/html4/#{file}")
+      #  load_entities_from_file(file)
+      end
+    end
+    translate_entities(doc, with_xmldecl)
+  end
+
+  def self.load_entities_from_file(filename)
+    File.read(filename).scan(/<!ENTITY +(.+?) +CDATA +"(.+?)".+?>/m) do |ent,code|
+      @entities[ent] = code
+    end
+  end
+
+  def self.translate_entities(doc, with_xmldecl = true)
+    oldclass = doc.class
+    doc = doc.to_s
+
+    @entities.each do |ent,code|
+      doc.gsub!("&#{ent};", code)
+    end
+
+    doc = "<?xml version='1.0' encoding='utf-8'?>\n#{doc}" if with_xmldecl
+
+    if oldclass == REXML::Element
+      REXML::Document.new(doc).root
+    else
+      doc
+    end
+  end
+end
+

data/lib/harvester/generator/link_absolutizer.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+class Harvester; class Generator; end; end
+
+# This module rewrites relative to absolute links
+module Harvester::Generator::LinkAbsolutizer
+  def self.run(body, base, logger = nil)
+    logger ||= Logger.new(STDOUT)
+    require 'hpricot'
+
+    html = Hpricot("<html><body>#{body}</body></html>")
+    (html/'a').each { |a|
+      begin
+        f = a.get_attribute('href')
+        t = URI::join(base, f.to_s).to_s
+        logger.debug "* rewriting #{f.inspect} => #{t.inspect}" if f != t
+        a.set_attribute('href', t)
+      rescue URI::Error
+        logger.debug "* cannot rewrite relative URL: #{a.get_attribute('href').inspect}" unless a.get_attribute('href') =~ /^[a-z]{2,10}:/
+      end
+    }
+    (html/'img').each { |img|
+      begin
+        f = img.get_attribute('src')
+        t = URI::join(base, f.to_s).to_s
+        logger.debug "* rewriting #{f.inspect} => #{t.inspect}" if f != t
+        img.set_attribute('src', t)
+      rescue URI::Error
+        logger.debug "* cannot rewrite relative URL: #{img.get_attribute('href').inspect}" unless img.get_attribute('href') =~ /^[a-z]{2,10}:/
+      end
+    }
+    html.search('/html/body/*').to_s
+  rescue Hpricot::Error => e
+    logger.error "Hpricot::Error: #{e}"
+    body
+  rescue LoadError
+    logger.warn "* hpricot not found, will not mangle relative links in <description/>"
+    body
+  end
+end

data/lib/harvester/jabber.rb

@@ -0,0 +1,443 @@
+# encoding: ascii
+
+require_relative '../harvester'
+
+#require 'fastthread'
+require 'xmpp4r'
+require 'xmpp4r/discovery'
+require 'xmpp4r/version'
+require 'xmpp4r/roster'
+require 'xmpp4r/dataforms'
+require 'xmpp4r/vcard'
+
+TABLE_SUBSCRIPTIONS = 'jabbersubscriptions'
+TABLE_SETTINGS = 'jabbersettings'
+
+Jabber::debug = true
+
+class ChatState
+  def initialize(question, &block)
+    @question = question
+    @block = block
+  end
+end
+
+class ChatDialog
+  def initialize(&block)
+    @sendblock = block
+    @finished = false
+    @state = nil
+  end
+  def set_state(question, &state)
+    send question
+    @state = state
+  end
+  def send(str)
+    @sendblock.call str
+  end
+  def finished?
+    @finished
+  end
+  def finish!
+    @finished = true
+  end
+  def on_message(msg)
+    @state.call msg
+  end
+end
+
+class Interview < ChatDialog
+  def initialize(dbi, user, collections, &block)
+    raise 'No collections found!' unless collections.size > 0
+
+    super(&block)
+    @collections = collections
+    @collections_keys = collections.keys
+
+    set_state("Hello, I'm the Harvester Jabber service, aka NotAstroBot. " +
+              "Type \"start\" to subscribe to feeds selectively.") { |msg|
+      if msg == 'start'
+        
+        set_state("Should I respect your online status by sending you notifications only when you're online? Please notice that you need to grant authorization to receive presence updates from you in that case.") { |msg|
+          if msg == 'yes' or msg == 'no'
+            respect_status = (msg == 'yes')
+
+            set_state("What type of message may I send to you? Valid answers are \"normal\", \"headline\" and \"chat\".") { |msg|
+              if msg == 'normal' or msg == 'headline' or msg == 'chat'
+                dbi.do "DELETE FROM #{TABLE_SETTINGS} WHERE JID=?", user
+                dbi.do "INSERT INTO #{TABLE_SETTINGS} (jid, respect_status, message_type) VALUES (?, ?, ?)",
+                  user, respect_status, msg
+            
+                collections_i = 0
+
+                set_state(collection_question(collections_i)) { |msg|
+                  if msg == 'yes' or msg == 'no'
+                    puts "#{@collections_keys[collections_i]}: #{msg}"
+                    dbi.execute "DELETE FROM #{TABLE_SUBSCRIPTIONS} WHERE jid=? AND collection=?", user, @collections_keys[collections_i]
+                    if msg == 'yes'
+                      dbi.do "INSERT INTO #{TABLE_SUBSCRIPTIONS} (jid, collection) VALUES (?, ?)", user, @collections_keys[collections_i]
+                    end
+                    
+                    collections_i += 1
+                    if collections_i < @collections.size
+                      send collection_question(collections_i)
+                    else
+                      finish!
+                      set_state('We\'ve done this interview. Talk to me if you want to repeat.') { |msg|
+                      }
+                    end
+                  else
+                    send 'I don\'t understand you. Please reply with either "yes" or "no".'
+                  end
+                }
+              end
+            }
+          end
+        }
+      end
+    }
+  end
+
+  def collection_question(i)
+    if i >= @collections.size
+      nil
+    else
+      "Do you want to receive updates to the collection \"#{@collections_keys[i]}\", which include " + 
+        @collections[@collections_keys[i]].collect { |rss,title|
+          title
+        }.join(', ') + '? ("yes" or "no")'
+    end
+  end
+end
+
+
+def duration_to_s(duration)
+  d = duration.to_i
+  r = []
+  while d >= 24 * 60 * 60
+    r << "#{d / (24 * 60 * 60)} days"
+    d %= 24 * 60 * 60
+  end
+  while d >= 60 * 60
+    r << "#{d / (60 * 60)} hrs"
+    d %= 60 * 60
+  end
+  while d >= 60
+    r << "#{d / 60} min"
+    d %= 60
+  end
+  (r.size > 0) ? r.join(', ') : 'no time'
+end
+  
+
+class Harvester
+  def jabber!
+    warn "The jabber bot is not supported, yet. To nevertheless use it, remove this code line."; exit
+
+collections = {}
+
+dbi = @dbi
+config = @config
+
+cl = Jabber::Client.new Jabber::JID.new(config['jabber']['jid'])
+cl.on_exception { |e,|
+  puts "HICKUP: #{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+  begin
+    sleep 5
+    cl.connect config['jabber']['host'] || 'localhost'
+    cl.auth config['jabber']['password']
+  rescue
+    sleep 10
+    retry
+  end
+}
+cl.connect config['jabber']['host'] || 'localhost'
+cl.auth config['jabber']['password']
+
+Jabber::Version::SimpleResponder.new(cl, 'Harvester', '0.6', IO.popen('uname -sr') { |io| io.readlines.to_s.strip })
+
+roster = Jabber::Roster::Helper.new(cl)
+roster.add_subscription_request_callback { |item,presence|
+  puts "Accepting subscription request from #{presence.from}"
+  roster.accept_subscription(presence.from)
+
+  roster.add(presence.from.strip, presence.from.node, true)
+}
+
+@chatdialogs = {}
+@chatdialogs_lock = Mutex.new
+
+cl.add_message_callback { |msg|
+  puts "Message #{msg.type} from #{msg.from}: #{msg.body.inspect}"
+
+  if msg.type == :chat and msg.body
+    @chatdialogs_lock.synchronize {
+      unless @chatdialogs.has_key? msg.from
+        @chatdialogs[msg.from] = Interview.new(dbi, msg.from.strip.to_s, collections) { |str|
+          cl.send Jabber::Message.new(msg.from, str).set_type(:chat)
+        }
+      else
+        @chatdialogs[msg.from].on_message msg.body
+      end
+
+      @chatdialogs.delete_if { |jid,interview| interview.finished? }
+    }
+  end
+}
+
+cl.add_iq_callback { |iq|
+  answer = iq.answer
+  answer.type = :result
+
+  command = answer.first_element('command')
+  
+  if iq.type == :get and iq.query.kind_of? Jabber::Discovery::IqQueryDiscoInfo
+    if iq.query.node == 'config'
+      answer.query.add Jabber::Discovery::Identity.new('automation', 'Configure subscriptions', 'command-node')
+      [ 'jabber:x:data',
+        'http://jabber.org/protocol/commands'].each { |feature|
+          answer.query.add Jabber::Discovery::Feature.new(feature)
+      }
+    else
+      answer.query.add Jabber::Discovery::Identity.new('headline', 'Harvester Jabber service', 'rss')
+      [ Jabber::Discovery::IqQueryDiscoInfo.new.namespace,
+        Jabber::Discovery::IqQueryDiscoItems.new.namespace,
+        'http://jabber.org/protocol/commands'].each { |feature|
+          answer.query.add Jabber::Discovery::Feature.new(feature)
+      }
+    end
+  elsif iq.type == :get and iq.query.kind_of? Jabber::Discovery::IqQueryDiscoItems
+    if iq.query.node == 'http://jabber.org/protocol/commands'
+      answer.query.add Jabber::Discovery::Item.new(cl.jid, 'Configure subscriptions', 'config')
+    else
+      answer.query.add Jabber::Discovery::Item.new(cl.jid, 'Ad-hoc commands', 'http://jabber.org/protocol/commands')
+    end
+  elsif iq.type == :set and command and command.namespace == 'http://jabber.org/protocol/commands' and command.attributes['node'] == 'config'
+    x = command.first_element('x')
+    x = Jabber::Dataforms::XData.new.import(x) if x
+
+    user = iq.from.strip.to_s
+
+    if x.nil? or x.type != :submit
+      puts "#{iq.from} requested data form"
+      command.attributes['status'] = 'executing'
+      command.attributes['sessionid'] = Jabber::IdGenerator.instance.generate_id
+      x = command.add(Jabber::Dataforms::XData.new(:form))
+      x.add(Jabber::Dataforms::XDataTitle.new).text = 'Configure subscriptions'
+
+      respect_status = x.add(Jabber::Dataforms::XDataField.new('respect-status', :boolean))
+      respect_status.label = 'Respect your online status'
+      message_type = x.add(Jabber::Dataforms::XDataField.new('message-type', :list_single))
+      message_type.label = 'Message type of notifications'
+      message_type.options = {'normal'=>'Normal message',
+                              'chat'=>'Chat message',
+                              'headline'=>'Headline message'}
+      settings = dbi.execute "SELECT respect_status, message_type FROM #{TABLE_SETTINGS} WHERE jid=?", user
+      while setting = settings.fetch
+        respect_status.values = [(setting.shift ? '1' : '0')]
+        message_type.values = [setting.shift]
+      end
+
+      collections.keys.sort.each { |collection|
+        field = x.add(Jabber::Dataforms::XDataField.new("collection-#{collection}", :boolean))
+        field.label = "Receive notifications for collection #{collection}"
+        field.add(REXML::Element.new('desc')).text = collections[collection].collect { |rss,title| title }.join(', ')
+
+        field.values = ['0']
+        subscription = dbi.execute "SELECT jid FROM #{TABLE_SUBSCRIPTIONS} WHERE jid=? AND collection=?", user, collection
+        while subscription.fetch
+          field.values = ['1']
+        end
+      }
+    else
+      if x and x.type == :submit
+        puts "#{iq.from} submitted data form"
+
+        if x.field('respect-status') and x.field('message-type')
+          respect_status = x.field('respect-status').values.include? '1'
+          message_type = x.field('message-type').values.to_s
+
+          dbi.do "DELETE FROM #{TABLE_SETTINGS} WHERE jid=?", user
+          dbi.do "INSERT INTO #{TABLE_SETTINGS} (jid, respect_status, message_type) VALUES (?, ?, ?)",
+            user, respect_status, message_type
+        end
+
+        x.each_element('field') { |f|
+          if f.var =~ /^collection-(.+)$/
+            collection = $1
+            dbi.execute "DELETE FROM #{TABLE_SUBSCRIPTIONS} WHERE jid=? AND collection=?", user, collection
+            if f.values.to_s == '1'
+              dbi.do "INSERT INTO #{TABLE_SUBSCRIPTIONS} (jid, collection) VALUES (?, ?)", user, collection
+            end
+          end
+        }
+
+        command.delete_element 'x'
+        command.attributes['status'] = 'completed'
+        note = command.add(REXML::Element.new('note'))
+        note.attributes['type'] = 'info'
+        note.text = 'Thank you for making use of the advanced NotAstroBot configuration interface. You are truly worth being notified about all that hot stuff!'
+      else
+        # Do nothing, but send a result
+        puts "#{iq.from} #{command.attributes['action']} data form"
+
+        command.delete_element 'x'
+        command.attributes['status'] = 'canceled'
+      end
+    end
+  elsif iq.type == :get or iq.type == :get
+    answer.type = :error
+    answer.add Jabber::ErrorResponse.new('feature-not-implemented', 'The requested feature hasn\'t been implemented.')
+  else
+    answer = ' '
+  end
+
+  cl.send answer
+}
+
+cl.send Jabber::Presence.new(:chat, 'The modern Harvester Jabber Service (Public Beta)')
+
+messages_sent = 0
+startup = Time.new
+links = []
+dbi.execute("SELECT link FROM last48hrs").each { |link,|
+  links << link
+}
+
+chart_last_update = Time.at(0)
+chart_filename = "#{config['settings']['output']}/chart.jpg"
+avatar_hash = ""
+
+loop {
+  resend_presence = false
+
+  ###
+  # Update collections
+  ###
+  new_collections = Hash.new([])
+
+  sources = dbi.execute "SELECT collection,rss,title FROM sources ORDER BY collection,title"
+  while row = sources.fetch
+    collection, rss, title = row
+    new_collections[collection] += [[rss, title]]
+  end
+  
+  collections = new_collections
+
+  ###
+  # Find new items
+  ##
+  # This fetches all items from the last 48 hours,
+  # just to make sure to not miss anything due to
+  # timezone overlaps and so on.
+  ###
+  new_links = []
+  notifications = Hash.new([])
+  items = dbi.execute "SELECT rss, blogtitle, title, link, collection FROM last48hrs"
+  while row = items.fetch
+    rss, blogtitle, title, link, collection = row
+
+    unless links.include? link
+      puts "New: #{link} (#{blogtitle}: #{title})"
+      notifications[collection] += [[blogtitle, title, link]]
+
+      resend_presence = true
+    end
+    
+    new_links << link
+  end
+
+  notifications.keys.each { |collection|
+    text = "Updates for #{collection}:"
+    subject = []
+    
+    html = REXML::Element.new 'html'
+    html.add_namespace 'http://jabber.org/protocol/xhtml-im'
+    body = html.add REXML::Element.new('body')
+    body.add_namespace 'http://www.w3.org/1999/xhtml'
+    body.add(REXML::Element.new('h4')).text = "Updates for #{collection}"
+    ul = body.add(REXML::Element.new('ul'))
+    
+    notifications[collection].each { |blogtitle, title, link|
+      subject << blogtitle
+      text += "\n#{blogtitle}: #{title}\n#{link}"
+
+      li = ul.add(REXML::Element.new('li'))
+      li.add REXML::Text.new("#{blogtitle}: ")
+      a = li.add(REXML::Element.new('a'))
+      a.attributes['href'] = link
+      a.text = title
+    }
+
+    puts "#{Time.new} - #{text.inspect}"
+
+    ##
+    # Prepare subject
+    subject.uniq!
+    subject.sort! { |a,b| a.downcase <=> b.downcase }
+
+    ##
+    # Send for all who have subscribed
+    subscriptions = dbi.execute "SELECT jid FROM #{TABLE_SUBSCRIPTIONS} WHERE collection=?", collection
+    while row = subscriptions.fetch
+      jid, = row
+
+      respect_status = false
+      message_type = :headline
+      settings = dbi.execute "SELECT respect_status, message_type FROM #{TABLE_SETTINGS} WHERE jid=?", jid
+      while setting = settings.fetch
+        respect_status = setting.shift
+        message_type = setting.shift.intern
+      end
+ 
+      if (respect_status and (roster[jid] ? roster[jid].online? : false)) or not respect_status
+        msg = Jabber::Message.new
+        msg.to, = jid
+        msg.type = message_type
+        msg.subject = subject.join', '
+        msg.body = text
+        msg.add html
+        cl.send msg
+      end
+
+      messages_sent += 1
+    end
+  }
+
+  links = new_links
+
+  ##
+  # Avatar
+  ##
+  if File::ctime(chart_filename) > chart_last_update
+    chart_last_update = File::ctime(chart_filename)
+
+    photo = IO::readlines(chart_filename).to_s
+    avatar_hash = Digest::SHA1.hexdigest(photo)
+    vcard = Jabber::Vcard::IqVcard.new('NICKNAME' => 'NotAstrobot',
+                                       'FN' => 'Harvester Jabber notification',
+                                       'URL' => 'http://localhost/',
+                                       'PHOTO/TYPE' => 'image/jpeg',
+                                       'PHOTO/BINVAL' => Base64::encode64(photo))
+    Jabber::Vcard::Helper::set(cl, vcard)
+    resend_presence = true
+  end
+
+  if resend_presence
+    pres = Jabber::Presence.new(:chat,
+                                "Sent #{messages_sent} messages in #{duration_to_s(Time.new - startup)}. Chewed #{links.size} feed items in the last 48 hours.")
+    x = pres.add(REXML::Element.new('x'))
+    x.add_namespace 'vcard-temp:x:update'
+    x.add(REXML::Element.new('photo')).text = avatar_hash
+    cl.send pres
+  end
+
+  ###
+  # Loop
+  ###
+  print '.'; $stdout.flush
+  sleep config['jabber']['interval'].to_i
+}
+
+  end
+end