postrunner 0.0.11 → 0.1.0

data/lib/postrunner/DataSources.rb

@@ -55,7 +55,7 @@ module PostRunner
       start_time = session.start_time
       @fit_activity.data_sources.each do |source|
         t.cell(secsToHMS(source.timestamp - start_time))
-        t.cell(distance(source.timestamp))
+        t.cell(@activity.distance(source.timestamp, @unit_system))
         t.cell(source.mode)
         t.cell(device_name(source.distance))
         t.cell(device_name(source.speed))
@@ -81,19 +81,6 @@ module PostRunner
       ''
     end
 
-    def distance(timestamp)
-      @fit_activity.records.each do |record|
-        if record.timestamp >= timestamp
-          unit = { :metric => 'km', :statute => 'mi'}[@unit_system]
-          value = record.get_as('distance', unit)
-          return '-' unless value
-          return "#{'%.2f %s' % [value, unit]}"
-        end
-      end
-
-      '-'
-    end
-
   end
 
 end

data/lib/postrunner/DeviceList.rb

@@ -55,19 +55,29 @@ module PostRunner
 
     def devices
       tables = []
-      seen_indexes = []
+      unique_devices = []
+      # Search the device list from back to front and save the first occurance
+      # of each device index.
       @fit_activity.device_infos.reverse_each do |device|
-        next if seen_indexes.include?(device.device_index)
+        unless unique_devices.find { |d| d.device_index == device.device_index }
+          unique_devices << device
+        end
+      end
 
+      unique_devices.sort { |d1, d2| d1.device_index <=>
+                                     d2.device_index }.each do |device|
         tables << (t = FlexiTable.new)
-        t.set_html_attrs(:style, 'margin-bottom: 15px') if tables.length != 1
+        if tables.length != unique_devices.length
+          t.set_html_attrs(:style, 'margin-bottom: 15px')
+        end
         t.body
 
         t.cell('Index:', { :width => '40%' })
         t.cell(device.device_index.to_s, { :width => '60%' })
         t.new_row
 
-        if (manufacturer = device.manufacturer)
+        if (manufacturer = device.manufacturer) &&
+           manufacturer != 'Undocumented value 0'
           t.cell('Manufacturer:', { :width => '40%' })
           t.cell(manufacturer.upcase, { :width => '60%' })
           t.new_row
@@ -75,7 +85,7 @@ module PostRunner
 
         if (product = %w( garmin dynastream dynastream_oem ).include?(
             device.manufacturer) ? device.garmin_product : device.product) &&
-           product != 0xFFFF
+           product != 0xFFFF && product != 0
           # For unknown products the numerical ID will be returned.
           product = product.to_s unless product.is_a?(String)
           t.cell('Product:')
@@ -100,9 +110,9 @@ module PostRunner
           t.new_row
         end
 
-        if device.software_version
+        if (version = device.software_version) && version != 0.0
           t.cell('Software Version:')
-          t.cell(device.software_version)
+          t.cell(version)
           t.new_row
         end
 
@@ -123,11 +133,9 @@ module PostRunner
           t.cell(secsToDHMS(device.cum_operating_time))
           t.new_row
         end
-
-        seen_indexes << device.device_index
       end
 
-      tables.reverse
+      tables
     end
 
   end

data/lib/postrunner/DirUtils.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = DirUtils.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2014, 2015 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'fileutils'
+
+module PostRunner
+
+  module DirUtils
+
+    def create_directory(dir, name)
+      return if Dir.exists?(dir)
+
+      Log.info "Creating #{name} directory #{dir}"
+      begin
+        FileUtils.mkdir_p(dir)
+      rescue StandardError
+        Log.fatal "Cannot create #{name} directory #{dir}: #{$!}"
+      end
+    end
+
+  end
+
+end
+

data/lib/postrunner/EventList.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = EventList.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2015, 2016 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'fit4ruby'
+
+require 'postrunner/FlexiTable'
+require 'postrunner/ViewFrame'
+require 'postrunner/DeviceList'
+
+module PostRunner
+
+  # The EventList objects can generate a table that lists all the recorded
+  # FIT file events in chronological order.
+  class EventList
+
+    include Fit4Ruby::Converters
+
+    # Create a DataSources object.
+    # @param activity [Activity] The activity to analyze.
+    # @param unit_system [Symbol] The unit system to use (:metric or
+    #        :imperial )
+    def initialize(activity, unit_system)
+      @activity = activity
+      @fit_activity = activity.fit_activity
+      @unit_system = unit_system
+    end
+
+    # Return the list as ASCII table
+    def to_s
+      list.to_s
+    end
+
+    # Add the list as HTML table to the specified doc.
+    # @param doc [HTMLBuilder] HTML document
+    def to_html(doc)
+      ViewFrame.new("Events", 600, list).to_html(doc)
+    end
+
+    private
+
+    def list
+      session = @fit_activity.sessions[0]
+
+      t = FlexiTable.new
+      t.enable_frame(false)
+      t.body
+      t.row([ 'Time', 'Distance', 'Description', 'Value' ])
+      t.set_column_attributes([
+        { :halign => :right },
+        { :halign => :right },
+        { :halign => :left },
+        { :halign => :right }
+      ])
+      start_time = session.start_time
+      @fit_activity.events.each do |event|
+        t.cell(secsToHMS(event.timestamp - start_time))
+        t.cell(@activity.distance(event.timestamp, @unit_system))
+        event_name_and_value(t, event)
+        t.new_row
+      end
+
+      t
+    end
+
+    def event_name_and_value(table, event)
+      case event.event
+      when 'timer'
+        name = "Timer (#{event.event_type.gsub(/_/, ' ')})"
+        value = event.timer_trigger
+      when 'course_point'
+        name = 'Course Point'
+        value = event.message_index
+      when 'battery'
+        name = 'Battery Level'
+        value = "#{event.battery_level} V"
+      when 'hr_high_alert'
+        name = 'HR high alert'
+        value = "#{event.hr_high_alert} bpm"
+      when 'hr_low_alert'
+        name = 'HR low alert'
+        value = "#{event.hr_low_alert} bpm"
+      when 'speed_high_alert'
+        name = 'Speed high alert'
+        value = event.speed_high_alert
+      when 'speed_low_alert'
+        name = 'Speed low alert'
+        value = event.speed_low_alert
+      when 'cad_high_alert'
+        name = 'Cadence high alert'
+        value = "#{event.cad_high_alert} spm"
+      when 'cad_low_alert'
+        name = 'Cadence low alert'
+        value = "#{event.cad_low_alert} spm"
+      when 'power_high_alert'
+        name = 'Power high alert'
+        value = event.power_high_alert
+      when 'power_low_alert'
+        name = 'Power low alert'
+        value = event.power_low_alert
+      when 'time_duration_alert'
+        name = 'Time duration alert'
+        value = event.time_duration_alert
+      when 'calorie_duration_alert'
+        name = 'Calorie duration alert'
+        value = event.calorie_duration_alert
+      when 'fitness_equipment'
+        name = 'Fitness equipment state'
+        value = event.fitness_equipment_state
+      when 'rider_position'
+        name 'Rider position changed'
+        value = event.rider_position
+      when 'comm_timeout'
+        name 'Communication timeout'
+        value = event.comm_timeout
+      when 'recovery_hr'
+        name = 'Recovery heart rate'
+        value = "#{event.recovery_hr} bpm"
+      when 'recovery_time'
+        name = 'Recovery time'
+        value = "#{secsToDHMS(event.recovery_time * 60)}"
+      when 'recovery_info'
+        name = 'Recovery info'
+        mins = event.recovery_info
+        value = "#{secsToDHMS(mins * 60)} (#{mins < 24 * 60 ? 'Good' : 'Poor'})"
+      when 'vo2max'
+        name = 'VO2Max'
+        value = event.vo2max
+      else
+        name = event.event
+        value = event.data
+      end
+
+      table.cell(name)
+      table.cell(value)
+    end
+
+  end
+
+end
+

data/lib/postrunner/FFS_Activity.rb

@@ -0,0 +1,297 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FFS_Activity.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2015, 2016 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'fit4ruby'
+require 'perobs'
+
+require 'postrunner/ActivitySummary'
+require 'postrunner/DataSources'
+require 'postrunner/EventList'
+require 'postrunner/ActivityView'
+require 'postrunner/Schema'
+require 'postrunner/QueryResult'
+require 'postrunner/DirUtils'
+
+module PostRunner
+
+  # The FFS_Activity objects can store a reference to the FIT file data and
+  # caches some frequently used values. In some cases the cached values can be
+  # used to overwrite the data from the FIT file.
+  class FFS_Activity < PEROBS::Object
+
+    include DirUtils
+
+    @@Schemata = {
+      'long_date' => Schema.new('long_date', 'Date',
+                                { :func => 'timestamp',
+                                  :column_alignment => :left,
+                                  :format => 'date_with_weekday' }),
+      'sub_type' => Schema.new('sub_type', 'Subtype',
+                               { :func => 'activity_sub_type',
+                                 :column_alignment => :left }),
+      'type' => Schema.new('type', 'Type',
+                           { :func => 'activity_type',
+                             :column_alignment => :left })
+    }
+
+    ActivityTypes = {
+      'generic' => 'Generic',
+      'running' => 'Running',
+      'cycling' => 'Cycling',
+      'transition' => 'Transition',
+      'fitness_equipment' => 'Fitness Equipment',
+      'swimming' => 'Swimming',
+      'basketball' => 'Basketball',
+      'soccer' => 'Soccer',
+      'tennis' => 'Tennis',
+      'american_football' => 'American Football',
+      'walking' => 'Walking',
+      'cross_country_skiing' => 'Cross Country Skiing',
+      'alpine_skiing' => 'Alpine Skiing',
+      'snowboarding' => 'Snowboarding',
+      'rowing' => 'Rowing',
+      'mountaineering' => 'Mountaneering',
+      'hiking' => 'Hiking',
+      'multisport' => 'Multisport',
+      'paddling' => 'Paddling',
+      'all' => 'All'
+    }
+    ActivitySubTypes = {
+      'generic' => 'Generic',
+      'treadmill' => 'Treadmill',
+      'street' => 'Street',
+      'trail' => 'Trail',
+      'track' => 'Track',
+      'spin' => 'Spin',
+      'indoor_cycling' => 'Indoor Cycling',
+      'road' => 'Road',
+      'mountain' => 'Mountain',
+      'downhill' => 'Downhill',
+      'recumbent' => 'Recumbent',
+      'cyclocross' => 'Cyclocross',
+      'hand_cycling' => 'Hand Cycling',
+      'track_cycling' => 'Track Cycling',
+      'indoor_rowing' => 'Indoor Rowing',
+      'elliptical' => 'Elliptical',
+      'stair_climbing' => 'Stair Climbing',
+      'lap_swimming' => 'Lap Swimming',
+      'open_water' => 'Open Water',
+      'flexibility_training' => 'Flexibility Training',
+      'strength_training' => 'Strength Training',
+      'warm_up' => 'Warm up',
+      'match' => 'Match',
+      'exercise' => 'Excersize',
+      'challenge' => 'Challenge',
+      'indoor_skiing' => 'Indoor Skiing',
+      'cardio_training' => 'Cardio Training',
+      'all' => 'All'
+    }
+
+    po_attr :device, :fit_file_name, :norecord, :name, :sport, :sub_sport,
+            :timestamp, :total_distance, :total_timer_time, :avg_speed
+    attr_reader :fit_activity
+
+    # Create a new FFS_Activity object.
+    # @param p [PEROBS::Handle] PEROBS handle
+    # @param fit_file_name [String] The fully qualified file name of the FIT
+    #        file to add
+    # @param fit_entity [Fit4Ruby::FitEntity] The content of the loaded FIT
+    #        file
+    def initialize(p, device, fit_file_name, fit_entity)
+      super(p)
+
+      self.device = device
+      self.fit_file_name = fit_file_name ? File.basename(fit_file_name) : nil
+      self.name = fit_file_name ? File.basename(fit_file_name) : nil
+      self.norecord = false
+      if (@fit_activity = fit_entity)
+        self.timestamp = fit_entity.timestamp
+        self.total_timer_time = fit_entity.total_timer_time
+        self.sport = fit_entity.sport
+        self.sub_sport = fit_entity.sub_sport
+        self.total_distance = fit_entity.total_distance
+        self.avg_speed = fit_entity.avg_speed
+      end
+    end
+
+    # Store a copy of the given FIT file in the corresponding directory.
+    # @param fit_file_name [String] Fully qualified name of the FIT file.
+    def store_fit_file(fit_file_name)
+      # Get the right target directory for this particular FIT file.
+      dir = @store['file_store'].fit_file_dir(File.basename(fit_file_name),
+                                              @device.long_uid, 'activity')
+      # Create the necessary directories if they don't exist yet.
+      create_directory(dir, 'Device activity diretory')
+
+      # Copy the file into the target directory.
+      begin
+        FileUtils.cp(fit_file_name, dir)
+      rescue StandardError
+        Log.fatal "Cannot copy #{fit_file_name} into #{dir}: #{$!}"
+      end
+    end
+
+    # FFS_Activity objects are sorted by their timestamp values and then by
+    # their device long_uids.
+    def <=>(a)
+      @timestamp == a.timestamp ? a.device.long_uid <=> self.device.long_uid :
+        a.timestamp <=> @timestamp
+    end
+
+    def check
+      generate_html_report
+      Log.info "FIT file #{@fit_file_name} is OK"
+    end
+
+    def dump(filter)
+      load_fit_file(filter)
+    end
+
+    def dump(filter)
+      load_fit_file(filter)
+    end
+
+    def query(key)
+      unless @@Schemata.include?(key)
+        raise ArgumentError, "Unknown key '#{key}' requested in query"
+      end
+
+      schema = @@Schemata[key]
+
+      if schema.func
+        value = send(schema.func)
+      else
+        unless instance_variable_defined?(key)
+          raise ArgumentError, "Don't know how to query '#{key}'"
+        end
+        value = instance_variable_get(key)
+      end
+
+      QueryResult.new(value, schema)
+    end
+
+    def events
+      load_fit_file
+      puts EventList.new(self, @store['config']['unit_system']).to_s
+    end
+
+    def show
+      html_file = html_file_name
+
+      generate_html_report #unless File.exists?(html_file)
+
+      @store['file_store'].show_in_browser(html_file)
+    end
+
+    def sources
+      load_fit_file
+      puts DataSources.new(self, @store['config']['unit_system']).to_s
+    end
+
+    def summary
+      load_fit_file
+      puts ActivitySummary.new(self, @store['config']['unit_system'],
+                               { :name => @name,
+                                 :type => activity_type,
+                                 :sub_type => activity_sub_type }).to_s
+    end
+
+    def set(attribute, value)
+      case attribute
+      when 'name'
+        self.name = value
+      when 'type'
+        load_fit_file
+        unless ActivityTypes.values.include?(value)
+          Log.fatal "Unknown activity type '#{value}'. Must be one of " +
+                    ActivityTypes.values.join(', ')
+        end
+        self.sport = ActivityTypes.invert[value]
+      when 'subtype'
+        unless ActivitySubTypes.values.include?(value)
+          Log.fatal "Unknown activity subtype '#{value}'. Must be one of " +
+                    ActivitySubTypes.values.join(', ')
+        end
+        self.sub_sport = ActivitySubTypes.invert[value]
+      when 'norecord'
+        unless %w( true false).include?(value)
+          Log.fatal "norecord must either be 'true' or 'false'"
+        end
+        self.norecord = value == 'true'
+      else
+        Log.fatal "Unknown activity attribute '#{attribute}'. Must be one of " +
+                  'name, type or subtype'
+      end
+      generate_html_report
+    end
+
+    # Return true if this activity generated any personal records.
+    def has_records?
+      !@store['records'].activity_records(self).empty?
+    end
+
+    def html_file_name(full_path = true)
+      fn = "#{@device.short_uid}_#{@fit_file_name[0..-5]}.html"
+      full_path ? File.join(@store['config']['html_dir'], fn) : fn
+    end
+
+    def generate_html_report
+      load_fit_file
+      ActivityView.new(self, @store['config']['unit_system'])
+    end
+
+    def activity_type
+      ActivityTypes[@sport] || 'Undefined'
+    end
+
+    def activity_sub_type
+      ActivitySubTypes[@sub_sport] || 'Undefined'
+    end
+
+    def distance(timestamp, unit_system)
+      load_fit_file
+
+      @fit_activity.records.each do |record|
+        if record.timestamp >= timestamp
+          unit = { :metric => 'km', :statute => 'mi'}[unit_system]
+          value = record.get_as('distance', unit)
+          return '-' unless value
+          return "#{'%.2f %s' % [value, unit]}"
+        end
+      end
+
+      '-'
+    end
+
+    def load_fit_file(filter = nil)
+      return if @fit_activity
+
+      dir = @store['file_store'].fit_file_dir(@fit_file_name,
+                                              @device.long_uid, 'activity')
+      fit_file = File.join(dir, @fit_file_name)
+      begin
+        @fit_activity = Fit4Ruby.read(fit_file, filter)
+      rescue Fit4Ruby::Error
+        Log.fatal "#{@fit_file_name} corrupted: #{$!}"
+      end
+
+      unless @fit_activity
+        Log.fatal "#{fit_file} does not contain any activity records"
+      end
+    end
+
+    private
+
+  end
+
+end
+