achoo 0.3 → 0.4.1

data/lib/achoo/achievo/hour_registration_form_ranged.rb

@@ -0,0 +1,49 @@
+require 'achoo/achievo'
+
+module Achoo
+  module Achievo
+    class HourRegistrationFormRanged < HourRegistrationForm
+
+      def initialize(agent)
+        super
+        
+        @page = @agent.get(atk_submit_to_url(@page.link_with(:text => 'Select range').href))
+        @form = @page.form('entryform')
+      end
+
+      def date=(date_range)
+        super(date_range[0])
+
+        to_day_field.value   = date_range[1].strftime('%d')
+        to_month_field.value = date_range[1].strftime('%m')
+        to_year_field.value  = date_range[1].year
+      end
+
+      def date
+        start = super
+        finish = Date.new(to_year_field.value.to_i, to_month_field.value.to_i, 
+                          to_day_field.value.to_i)
+        [start, finish]
+      end
+      
+      private
+
+      def to_day_field
+        @form.field_with(:name => 'todate[day]')
+      end
+
+      def to_month_field
+        @form.field_with(:name => 'todate[month]')
+      end
+
+      def to_year_field
+        @form.field_with(:name => 'todate[year]')
+      end
+
+      def date_to_s
+        date.map {|d| d.strftime("%Y-%m-%d")}.join(" -> ")
+      end
+      
+    end
+  end
+end

data/lib/achoo/achievo/lock_month_form.rb

@@ -0,0 +1,44 @@
+require 'achoo/achievo'
+
+module Achoo
+  module Achievo
+    class LockMonthForm
+
+      def initialize(agent)
+        @agent = agent
+      end
+
+      def lock_month(period)
+        page  = @agent.get(RC[:lock_months_url])
+        @form  = page.form('entryform')
+
+        @form.period = period
+        unless user_select.nil?
+          user_select.options.each do |opt|
+            if opt.text.match(/\(#{RC[:user]}\)$/)
+              opt.select
+            end
+          end
+        end
+
+      end
+
+      def print_values
+        puts "Month: #{@form.period}"
+        puts " User: #{user_select.value}" unless user_select.nil?
+
+      end
+      
+      def submit
+        @form.submit
+      end
+
+      private
+
+      def user_select
+        @form.field_with(:name => 'userid')
+      end
+      
+    end
+  end
+end

data/lib/achoo/achievo/login_form.rb

@@ -0,0 +1,27 @@
+require 'achoo/achievo'
+
+module Achoo
+  module Achievo
+    module LoginForm
+
+      def self.login(agent)
+        puts "Fetching data ..."
+        page = agent.get(RC[:url])
+
+        return if page.forms.empty? # already logged in
+
+        puts "Logging in ..."
+
+        form = page.forms.first
+        form.auth_user = RC[:user]
+        form.auth_pw   = RC[:password]
+        page = agent.submit(form, form.buttons.first)
+
+        if page.body.match(/Username and\/or password are incorrect. Please try again./)
+          raise "Username and/or password are incorrect."
+        end
+      end
+
+    end
+  end
+end

data/lib/achoo/achievo/table.rb

@@ -0,0 +1,30 @@
+require 'achoo/achievo'
+
+module Achoo
+  module Achievo
+    class Table < Array
+
+      def initialize(source_rows)
+        super()
+        source_rows.each do |tr|
+          cells = tr.css('td, th')
+          cells = cells.collect {|c| c.content.strip}
+          self << fix_empty_cells(cells)
+        end
+      end
+
+      def select_columns(&block)
+        columns = transpose
+        columns = columns.select &block
+        replace(columns.transpose)
+      end
+
+      private
+
+      def fix_empty_cells(row)
+        row.collect {|c| c == "\302\240" ? ' ' : c} # UTF-8 NO-BREAK-SPACE
+      end
+
+    end
+  end
+end

data/lib/achoo/app.rb

@@ -0,0 +1,153 @@
+require 'achoo'
+require 'achoo/achievo'
+require 'achoo/term'
+require 'achoo/ui'
+require 'logger'
+require 'mechanize'
+
+
+module Achoo
+  class App
+
+    include UI::Commands
+    include UI::ExceptionHandling
+    include UI::RegisterHours
+    
+
+    def initialize(log=false)
+      @agent = Mechanize.new
+      if log
+        @agent.log = Logger.new("achoo_http.log")
+      end
+    end
+
+
+    def start
+      begin
+        print_welcome
+        warm_up_ical_cache
+        login
+        scrape_urls
+        command_loop
+      rescue SystemExit => e
+        raise
+      rescue Exception => e
+        handle_fatal_exception("Something bad happened. Shutting down.", e)
+      end
+    end
+
+
+    private
+
+
+    def print_welcome
+      puts Term.shadowbox("Welcome to Achoo!")
+    end
+
+
+    def command_loop
+      while true
+        begin
+          trap("INT", "DEFAULT");
+          choices = ["Register hours",
+                     "Show flexitime balance",
+                     "Day hour report",
+                     "Week hour report",
+                     "Holiday balance",
+                     "Lock month",
+                    ]
+          choices << "Time survey report" if RC[:reports]
+          answer = Term.choose('[1]',
+                               choices,
+                               "Exit",
+                               ['q', 'Q', ''])
+          dispatch(answer)
+        rescue Interrupt
+          puts # Add a new line in case we are prompting
+        end
+      end
+    end
+
+    
+    def dispatch(command)
+      case command
+      when '0', 'q', 'Q'
+        exit
+      when '1', ''
+        register_hours(@agent)
+      when '2'
+        show_flexi_time(@agent)
+      when '3'
+        show_registered_hours_for_day(@agent)
+      when '4'
+        show_registered_hours_for_week(@agent)
+      when '5'
+        show_holiday_report(@agent)
+      when '6'
+        lock_month(@agent)
+      when '7'
+        view_report(@agent)
+      end
+    end
+
+
+    def scrape_urls 
+      page = @agent.get(@agent.current_page.frames.find {|f| f.name == 'menu'}.href)
+      menu_links = page.search('a.menuItemLevel2')
+      
+      RC[:hour_registration_url] = menu_link_to_url(menu_links, 'Time Registration')
+      RC[:lock_months_url]       = menu_link_to_url(menu_links, 'Lock months')
+      RC[:holiday_report_url]    = menu_link_to_url(menu_links, 'Holiday report')
+      RC[:hour_admin_url]        = RC[:hour_registration_url]
+    end
+
+
+    def menu_link_to_url(menu_links, text)
+      a_tag = menu_links.find {|a| 
+        a.text.strip == text
+      }
+      
+      if a_tag.nil?
+        raise Exception.new("Could not find the '#{text}' link in Achievo.\nMake sure that language is 'English' and theme is 'no value' in Achievo's user preferences.\nYou must delete ~/.achoo_cookies.yml for these changes to take affect.")
+      end
+
+      url = a_tag.attribute('onclick').value.match(/window\.open\('([^']+)/)[1]
+      return "#{RC[:url]}#{url}"
+    end
+
+
+    def login
+      load_cookies
+      Achievo::LoginForm.login(@agent)
+      save_cookies
+    end
+
+
+    def load_cookies
+      cookies_file = "#{ENV['HOME']}/.achoo_cookies.yml"
+      if FileTest.exists? cookies_file
+        @agent.cookie_jar.load(cookies_file)
+      end
+    end
+
+
+    def save_cookies
+      @agent.cookie_jar.save_as("#{ENV['HOME']}/.achoo_cookies.yml")
+    end
+
+
+    def warm_up_ical_cache
+      Thread.new do 
+        RC[:ical].each do |config|
+          begin
+            ICal.from_http_request(config)
+          rescue Exception => e
+            # Ignore, we are just doing this to populate the cache
+          end
+        end
+      end
+    end
+
+  end
+end
+

data/lib/achoo/awake.rb

@@ -1,130 +1,116 @@
-require 'achoo/open_timespan'
-require 'achoo/timespan'
+require 'achoo'
+require 'achoo/extensions'
 require 'achoo/system'
+require 'achoo/temporal'
 
-class Achoo; end
+module Achoo
+  class Awake
 
-class Achoo::Awake
-    
-  def initialize
-    log = array_merge(wtmp, suspend) {|a, b| a[0] >= b[0] }
-    log.unshift([Time.now, :now])
-    @sessions = sessions(log)
-  end
+    def initialize
+      log = wtmp.merge!(suspend)
+      log.unshift(System::LogEntry.new(Time.now, :now))
+      @sessions = sessions(log)
+    end
 
-  def at(date)
-    span = Achoo::Timespan.new(date, date+1)
-    @sessions.each do |s|
-      print_session(s, span) if s[0].overlaps?(span)
+    def at(date)
+      span = Temporal::Timespan.new(date, date+1)
+      @sessions.each do |s|
+        print_session(s, span) if s[0].overlaps?(span)
+      end
     end
-  end
   
-  def all
-    @sessions.each do |s|
-      print_session(s)
+    def all
+      @sessions.each do |s|
+        print_session(s)
+      end
     end
-  end
 
-  private
+    private
 
-  def print_session(s, span=nil)
-    puts "Powered on: " << s[0].to_s
-    s[1].each do |t|
-      puts "  Awake: " << t.to_s if span.nil? || t.overlaps?(span)
+    def print_session(s, span=nil)
+      puts "Powered on: " << s[0].to_s
+      s[1].each do |t|
+        puts "  Awake: " << t.to_s if span.nil? || t.overlaps?(span)
+      end
     end
-  end
 
-  def sessions(log)
-    sessions = []
-    group(log).each do |g|
-      raise "Session doesn't begin with a boot event" unless g.last[1] == :boot
-      
-      session = []
-      case g.first[1]
-      when :now, :halt, :suspend
-        # We know the end of the session
-        session << Achoo::Timespan.new(g.last[0], g.first[0])
-      else # :awake, :boot
-        # We don't know the end of the session
-        session << Achoo::OpenTimespan.new(g.last[0], g.first[0])
-        g.unshift([-1, :crash])
-      end
+    def sessions(log)
+      sessions = []
+      group(log).each do |g|
+        raise "Session doesn't begin with a boot event" unless g.last.event == :boot
+        
+        session = []
+        case g.first.event
+        when :now, :halt, :suspend
+          # We know the end of the session
+          session << Temporal::Timespan.new(g.last.time, g.first.time)
+        else # :awake, :boot
+          # We don't know the end of the session
+          session << Temporal::OpenTimespan.new(g.last.time, g.first.time)
+          g.unshift(System::LogEntry.new(-1, :crash))
+        end
       
-      raise "Session must consist of even number of events. Found #{g.length}" unless g.length.even?
-
+        raise "Session must consist of even number of events. Found #{g.length}" unless g.length.even?
+        
 
-      session << []
-      unless g.length == 2
-        i = 0
-        while i < g.length-1
-          klass = g[i][1] == :crash ? Achoo::OpenTimespan : Achoo::Timespan
-          session[1] << klass.new(g[i+1][0], g[i][0])
-          i += 2
+        session << []
+        unless g.length == 2
+          i = 0
+          while i < g.length-1
+            klass = g[i].event == :crash ? Temporal::OpenTimespan : Temporal::Timespan
+            session[1] << klass.new(g[i+1].time, g[i].time)
+            i += 2
+          end
         end
-      end
       
-      sessions << session
-    end
-    sessions
-  end
-
-  def array_merge(a1, a2)
-    array = []
-    until a1.empty? or a2.empty?
-      if yield(a1.first, a2.first)
-        array << a1.shift
-      else
-        array << a2.shift
+        sessions << session
       end
+      sessions
     end
-    array.concat(a1).concat(a2)
-    array
-  end
 
-  def suspend
-    log     = Achoo::System::PMSuspend.new.reverse
-    new_log = []
-    log.each do |entry|
-      new_log << [entry.time, entry.action == 'Awake.' ? :awake : :suspend]
+    def suspend
+      log     = System::PMSuspend.new.reverse
+      new_log = []
+      log.each do |entry|
+        new_log << System::LogEntry.new(entry.time, entry.event == 'Awake.' ? :awake : :suspend)
+      end
+      new_log
     end
-    new_log
-  end
 
-  def wtmp
-    log     = Achoo::System::Wtmp.new.reverse
-    new_log = []
-    log.each do |entry|
-      if entry.boot_event?
-        new_log << [entry.time, :boot]
-      elsif entry.halt_event?
-        new_log << [entry.time, :halt]
+    def wtmp
+      log     = System::Wtmp.new.reverse
+      new_log = []
+      log.each do |entry|
+        if entry.boot_event?
+          new_log << System::LogEntry.new(entry.time, :boot)
+        elsif entry.halt_event?
+          new_log << System::LogEntry.new(entry.time, :halt)
+        end
       end
+      new_log
     end
-    new_log
-  end
 
-  def group(log)
-    grouped_log = []
-    group = nil
-    log.each do |i|
-      if i[1] == :halt || i[1] == :now
-        group = [i]
-      else
-        if group.nil?
-          # Crashed
-          group = []
-        end
-        if i[1] == :boot
-          group << i
-          grouped_log << group
-          group = nil
+    def group(log)
+      grouped_log = []
+      group = nil
+      log.each do |i|
+        if i.event == :halt || i.event == :now
+          group = [i]
         else
+          if group.nil?
+            # Crashed
+            group = []
+          end
           group << i
-        end    
+          if i.event == :boot
+            grouped_log << group
+            group = nil
+          end    
+        end
       end
+      grouped_log
     end
-    grouped_log
-  end
 
 
+  end
 end