postrunner 0.0.11 → 0.1.0

data/lib/postrunner/FFS_Device.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FFS_Device.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 'perobs'
+require 'postrunner/FFS_Activity'
+
+module PostRunner
+
+  # Objects of this class can store the activities and monitoring data of a
+  # specific device. The device gets a random number assigned as a unique but
+  # anonymous ID. It also gets a long ID assigned that is a String of the
+  # manufacturer, the product name and the serial number concatenated by
+  # dashes. All objects are transparently stored in the PEROBS::Store.
+  class FFS_Device < PEROBS::Object
+
+    po_attr :activities, :monitorings, :short_uid, :long_uid
+
+    # Create a new FFS_Device object.
+    # @param p [PEROBS::Handle] p
+    # @param short_uid [Fixnum] A random number used a unique ID
+    # @param long_uid [String] A string consisting of the manufacturer and
+    #        product name and the serial number.
+    def initialize(p, short_uid, long_uid)
+      super(p)
+      self.short_uid = short_uid
+      self.long_uid = long_uid
+      restore
+    end
+
+    # Handle initialization of persistent attributes.
+    def restore
+      attr_init(:activities) { @store.new(PEROBS::Array) }
+      attr_init(:monitorings) { @store.new(PEROBS::Array) }
+    end
+
+    # Add a new FIT file for this device.
+    # @param fit_file_name [String] The full path to the FIT file
+    # @param fit_entity [Fit4Ruby::FitEntity] The content of the FIT file
+    # @param overwrite [Boolean] A flag to indicate if an existing file should
+    #        be replaced with the new one.
+    # @return [FFS_Activity or FFS_Monitoring] Corresponding entry in the
+    #         FitFileStore or nil if file could not be added.
+    def add_fit_file(fit_file_name, fit_entity, overwrite)
+      case fit_entity.class
+      when Fit4Ruby::Activity.class
+        entity = activity_by_file_name(File.basename(fit_file_name))
+        entities = @activities
+        type = 'activity'
+        new_entity_class = FFS_Activity
+      when Fit4Ruby::Monitoring.class
+        entity = monitoring_by_file_name(File.basename(fit_file_name))
+        entities = @monitorings
+        type = 'monitoring'
+        new_entity_class = FFS_Monitoring
+      else
+        Log.fatal "Unsupported FIT entity #{fit_entity.class}"
+      end
+
+      if entity
+        if overwrite
+          # Replace the old file. All meta-information will be lost.
+          entities.delete_if { |e| e.fit_file_name == fit_file_name }
+          entity = @store.new(new_entity_class, myself, fit_file_name,
+                              fit_entity)
+        else
+          Log.debug "FIT file #{fit_file_name} has already been imported"
+          # Refuse to replace the file.
+          return nil
+        end
+      else
+        # Don't add the entity if has deleted before and overwrite isn't true.
+        path = @store['file_store'].fit_file_dir(File.basename(fit_file_name),
+                                                 long_uid, type)
+        fq_fit_file_name = File.join(path, File.basename(fit_file_name))
+        if File.exists?(fq_fit_file_name) && !overwrite
+          Log.debug "FIT file #{fq_fit_file_name} has already been imported " +
+                    "and deleted"
+          return nil
+        end
+        # Add the new file to the list.
+        entity = @store.new(new_entity_class, myself, fit_file_name, fit_entity)
+      end
+      entity.store_fit_file(fit_file_name)
+      entities << entity
+      entities.sort!
+
+      # Scan the activity for any potential new personal records and register
+      # them.
+      if entity.is_a?(FFS_Activity)
+        records = @store['records']
+        records.scan_activity_for_records(entity, true)
+      end
+
+      entity
+    end
+
+    # Delete the given activity from the activity list.
+    # @param activity [FFS_Activity] activity to delete
+    def delete_activity(activity)
+      @activities.delete(activity)
+    end
+
+    # Return the activity with the given file name.
+    # @param file_name [String] Base name of the fit file.
+    # @return [FFS_Activity] Corresponding FFS_Activity or nil.
+    def activity_by_file_name(file_name)
+      @activities.find { |a| a.fit_file_name == file_name }
+    end
+
+    # Return the monitoring with the given file name.
+    # @param file_name [String] Base name of the fit file.
+    # @return [FFS_Activity] Corresponding FFS_Monitoring or nil.
+    def monitoring_by_file_name(file_name)
+      @monitorings.find { |a| a.fit_file_name == file_name }
+    end
+
+  end
+
+end
+

data/lib/postrunner/FitFileStore.rb

@@ -0,0 +1,372 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FitFileStore.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2014, 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/Log'
+require 'postrunner/DirUtils'
+require 'postrunner/FFS_Device'
+require 'postrunner/ActivityListView'
+require 'postrunner/ViewButtons'
+
+module PostRunner
+
+  # The FitFileStore stores all FIT file and provides access to the contained
+  # data.
+  class FitFileStore < PEROBS::Object
+
+    include DirUtils
+
+    po_attr :devices
+
+    attr_reader :store, :views
+
+    # Create a new FIT file store.
+    # @param p [PEROBS::Handle] PEROBS handle
+    def initialize(p)
+      super(p)
+      restore
+    end
+
+    # Setup non-persistent variables.
+    def restore
+      @data_dir = @store['config']['data_dir']
+      # Ensure that we have an Array in the store to hold all known devices.
+      @store['devices'] = @store.new(PEROBS::Hash) unless @store['devices']
+
+      @devices_dir = File.join(@data_dir, 'devices')
+      # It's generally not a good idea to store absolute file names in the
+      # database. We'll make an exception here as this is the only way to
+      # propagate this path to FFS_Activity or FFS_Monitoring objects. The
+      # store entry is updated on each program run, so the DB can be moved
+      # safely to another directory.
+      @store['config']['devices_dir'] = @devices_dir
+      create_directory(@devices_dir, 'devices')
+
+      # Define which View objects the HTML output will consist of. This
+      # doesn't really belong in this class but for now it's the best place
+      # to put it.
+      @views = ViewButtons.new([
+        NavButtonDef.new('activities.png', 'index.html'),
+        NavButtonDef.new('record.png', "records-0.html")
+      ])
+    end
+
+    # Version upgrade logic.
+    def handle_version_update
+      # Nothing here so far.
+    end
+
+    # Add a file to the store.
+    # @param fit_file_name [String] Name of the FIT file
+    # @param overwrite [TrueClass, FalseClass] If true, an existing file will
+    #        be replaced.
+    # @return [FFS_Activity or FFS_Monitoring] Corresponding entry in the
+    #         FitFileStore or nil if file could not be added.
+    def add_fit_file(fit_file_name, fit_entity = nil, overwrite = false)
+      # If we the file hasn't been read yet, read it in as a
+      # Fit4Ruby::Activity or Fit4Ruby::Monitoring entity.
+      unless fit_entity
+        return nil unless (fit_entity = read_fit_file(fit_file_name))
+      end
+
+      unless [ Fit4Ruby::Activity,
+               Fit4Ruby::Monitoring ].include?(fit_entity.class)
+        Log.critical "Unsupported FIT file type #{fit_entity.class}"
+      end
+
+      # Generate a String that uniquely identifies the device that generated
+      # the FIT file.
+      id = extract_fit_file_id(fit_entity)
+      long_uid = "#{id[:manufacturer]}-#{id[:product]}-#{id[:serial_number]}"
+
+      # Make sure the device that created the FIT file is properly registered.
+      device = register_device(long_uid)
+      # Store the FIT entity with the device.
+      entity = device.add_fit_file(fit_file_name, fit_entity, overwrite)
+
+      # The FIT file might be already stored or invalid. In that case we
+      # abort this method.
+      return nil unless entity
+
+      if fit_entity.is_a?(Fit4Ruby::Activity)
+        @store['records'].scan_activity_for_records(entity)
+
+        # Generate HTML file for this activity.
+        entity.generate_html_report
+
+        # The HTML activity views contain links to their predecessors and
+        # successors. After inserting a new activity, we need to re-generate
+        # these views as well.
+        if (pred = predecessor(entity))
+          pred.generate_html_report
+        end
+        if (succ = successor(entity))
+          succ.generate_html_report
+        end
+        # And update the index pages
+        generate_html_index_pages
+      end
+
+      Log.info "#{File.basename(fit_file_name)} " +
+               'has been successfully added to archive'
+
+      entity
+    end
+
+    # Delete an activity from the database. It will only delete the entry in
+    # the database. The original activity file will not be deleted from the
+    # file system.
+    # @param activity [FFS_Activity] Activity to delete
+    def delete_activity(activity)
+      pred = predecessor(activity)
+      succ = successor(activity)
+
+      activity.device.delete_activity(activity)
+
+      # The HTML activity views contain links to their predecessors and
+      # successors. After deleting an activity, we need to re-generate these
+      # views.
+      pred.generate_html_report if pred
+      succ.generate_html_report if succ
+
+      generate_html_index_pages
+    end
+
+    # Rename the specified activity and update all HTML pages that contain the
+    # name.
+    # @param activity [FFS_Activity] Activity to rename
+    # @param name [String] New name
+    def rename_activity(activity, name)
+      activity.set('name', name)
+      generate_html_index_pages
+    end
+
+    # Set the specified attribute of the given activity to a new value.
+    # @param activity [FFS_Activity] Activity to rename
+    # @param attribute [String] name of the attribute to change
+    # @param value [any] new value of the attribute
+    def set_activity_attribute(activity, attribute, value)
+      activity.set(attribute, value)
+      case attribute
+      when 'norecord', 'type'
+        # If we have changed a norecord setting or an activity type, we need
+        # to regenerate all reports and re-collect the record list since we
+        # don't know which Activity needs to replace the changed one.
+        check
+      end
+      generate_html_index_pages
+    end
+
+    # Perform the necessary report updates after the unit system has been
+    # changed.
+    def change_unit_system
+      # If we have changed the unit system we need to re-generate all HTML
+      # reports.
+      activities.each do |activity|
+        activity.generate_html_report
+      end
+      @store['records'].generate_html_reports
+      generate_html_index_pages
+    end
+    # Determine the right directory for the given FIT file. The resulting path
+    # looks something like /home/user/.postrunner/devices/garmin-fenix3-1234/
+    # activity/5A.
+    # @param fit_file_base_name [String] The base name of the fit file
+    # @param long_uid [String] the long UID of the device
+    # @param type [String] 'activity' or 'monitoring'
+    # @return [String] the full path name of the archived FIT file
+    def fit_file_dir(fit_file_base_name, long_uid, type)
+      # The first letter of the FIT file specifies the creation year.
+      # The second letter of the FIT file specifies the creation month.
+      File.join(@store['config']['devices_dir'],
+                long_uid, type, fit_file_base_name[0..1])
+    end
+
+
+
+    # @return [Array of FFS_Device] List of registered devices.
+    def devices
+      @store['devices']
+    end
+
+    # @return [Array of FFS_Activity] List of stored activities.
+    def activities
+      list = []
+      @store['devices'].each do |id, device|
+        list += device.activities
+      end
+      list.sort
+    end
+
+    # Return the reference index of the given FFS_Activity.
+    # @param activity [FFS_Activity]
+    # @return [Fixnum] Reference index as used in the UI
+    def ref_by_activity(activity)
+      return nil unless (idx = activities.index(activity))
+
+      idx + 1
+    end
+
+    # Return the next Activity after the provided activity. Note that this has
+    # a lower index. If none is found, return nil.
+    def successor(activity)
+      all_activities = activities
+      idx = all_activities.index(activity)
+      return nil if idx.nil? || idx == 0
+      all_activities[idx - 1]
+    end
+
+    # Return the previous Activity before the provided activity.
+    # If none is found, return nil.
+    def predecessor(activity)
+      all_activities = activities
+      idx = all_activities.index(activity)
+      return nil if idx.nil?
+      # Activities indexes are reversed. The predecessor has a higher index.
+      all_activities[idx + 1]
+    end
+
+    # Find a specific subset of the activities based on their index.
+    # @param query [String]
+    def find(query)
+      case query
+      when /\A-?\d+$\z/
+        index = query.to_i
+        # The UI counts the activities from 1 to N. Ruby counts from 0 -
+        # (N-1).
+        if index <= 0
+          Log.error 'Index must be larger than 0'
+          return []
+        end
+        # The UI counts the activities from 1 to N. Ruby counts from 0 -
+        # (N-1).
+        if (a = activities[index - 1])
+          return [ a ]
+        end
+      when /\A-?\d+--?\d+\z/
+        idxs = query.match(/(?<sidx>-?\d+)-(?<eidx>-?[0-9]+)/)
+        if (sidx = idxs['sidx'].to_i) <= 0
+          Log.error 'Start index must be larger than 0'
+          return []
+        end
+        if (eidx = idxs['eidx'].to_i) <= 0
+          Log.error 'End index must be larger than 0'
+          return []
+        end
+        if eidx < sidx
+          Log.error 'Start index must be smaller than end index'
+          return []
+        end
+        # The UI counts the activities from 1 to N. Ruby counts from 0 -
+        # (N-1).
+        unless (as = activities[(sidx - 1)..(eidx - 1)]).empty?
+          return as
+        end
+      else
+        Log.error "Invalid activity query: #{query}"
+      end
+
+      []
+    end
+
+    # This methods checks all stored FIT files for correctness, updates all
+    # indexes and re-generates all HTML reports.
+    def check
+      records = @store['records']
+      records.delete_all_records
+      activities.sort do |a1, a2|
+        a1.timestamp <=> a2.timestamp
+      end.each do |a|
+        a.check
+        records.scan_activity_for_records(a)
+      end
+      records.generate_html_reports
+      generate_html_index_pages
+    end
+
+    # Show the activity list in a web browser.
+    def show_list_in_browser
+      generate_html_index_pages
+      @store['records'].generate_html_reports
+      show_in_browser(File.join(@store['config']['html_dir'], 'index.html'))
+    end
+
+    def list_activities
+      puts ActivityListView.new(self).to_s
+    end
+
+    # Launch a web browser and show an HTML file.
+    # @param html_file [String] file name of the HTML file to show
+    def show_in_browser(html_file)
+      cmd = "#{ENV['BROWSER'] || 'firefox'} \"#{html_file}\" &"
+
+      unless system(cmd)
+        Log.fatal "Failed to execute the following shell command: #{$cmd}\n" +
+                  "#{$!}"
+      end
+    end
+
+    private
+
+    def read_fit_file(fit_file_name)
+      begin
+        return Fit4Ruby.read(fit_file_name)
+      rescue Fit4Ruby::Error
+        Log.error $!
+        return nil
+      end
+    end
+
+    def extract_fit_file_id(fit_entity)
+      fit_entity.device_infos.each do |di|
+        if di.device_index == 0
+          return {
+            :manufacturer => di.manufacturer,
+            :product => di.garmin_product || di.product,
+            :serial_number => di.serial_number
+          }
+        end
+      end
+      Log.fatal "Fit entity has no device info for 0"
+    end
+
+    def register_device(long_uid)
+      unless @store['devices'].include?(long_uid)
+        Log.info "New device registered: #{long_uid}"
+
+        # Generate a unique ID for the device that does not allow any insight
+        # on the number of and type of managed devices.
+        begin
+          short_uid = rand(2**32)
+        end while @store['devices'].find { |luid, d| d.short_uid == short_uid }
+
+        @store['devices'][long_uid] =
+          @store.new(FFS_Device, short_uid, long_uid)
+
+        # Create the directory to store the FIT files of this device.
+        create_directory(File.join(@devices_dir, long_uid), long_uid)
+      end
+
+      @store['devices'][long_uid]
+    end
+
+    def generate_html_index_pages
+      # Ensure that HTML index is up-to-date.
+      ActivityListView.new(myself).update_index_pages
+    end
+
+  end
+
+end
+