From 626db60658e3a18c1239cbcf7762450fc140f69d Mon Sep 17 00:00:00 2001
From: Claude
+ + <%= text_field_tag 'settings[max_timer_hours]', Stopwatch.settings['max_timer_hours'] || '10', size: 4, id: 'settings_max_timer_hours' %> + <%= t '.text_max_timer_hours' %> +
+<%= hidden_field_tag 'settings[highlighted_links]', '0', id: nil %> diff --git a/config/locales/en.yml b/config/locales/en.yml index 0ba535d..50f36d4 100644 --- a/config/locales/en.yml +++ b/config/locales/en.yml @@ -1,11 +1,14 @@ en: label_stopwatch_start: Start tracking label_stopwatch_stop: Stop tracking + text_stopwatch_timer_capped: "[Timer stopped automatically at the %{hours} hour limit - please check these hours]" stopwatch: settings: label_always_ask: 'Always ask' label_default_activity: 'Default activity for "Start tracking"' label_highlighted_links: "Color-code Start/Stop" + label_max_timer_hours: "Maximum timer length (hours)" + text_max_timer_hours: "A timer running longer than this is stopped at the limit and its entry is flagged in the comment. Leave blank or 0 for no limit." label_system: 'Use system default' stopwatch_timers: entries_list: diff --git a/init.rb b/init.rb index c44004e..829f9a7 100644 --- a/init.rb +++ b/init.rb @@ -9,6 +9,7 @@ Redmine::Plugin.register :stopwatch do settings default: { 'default_activity' => 'always_ask', 'highlighted_links' => '0', + 'max_timer_hours' => '10', }, partial: 'stopwatch/settings' menu :account_menu, :stopwatch, diff --git a/lib/stopwatch.rb b/lib/stopwatch.rb index 0d1a11a..afcec50 100644 --- a/lib/stopwatch.rb +++ b/lib/stopwatch.rb @@ -4,6 +4,7 @@ module Stopwatch def self.setup Stopwatch::IssuesControllerPatch.apply ::TimeEntry.prepend Stopwatch::TimeEntryPatch + ::Issue.prepend Stopwatch::IssuePatch ::User.prepend Stopwatch::UserPatch Stopwatch::Hooks # just load it end @@ -41,6 +42,15 @@ module Stopwatch end end + # Longest a timer may run before it is stopped automatically (hours), or nil for no limit. + # Protects against a forgotten timer adding a night or weekend to a time entry. + def self.max_timer_hours + value = settings['max_timer_hours'] + return 10.0 if value.nil? # setting never saved: use the default + hours = value.to_s.strip.tr(',', '.').to_f + hours.positive? ? hours : nil + end + # Colour-code the issue Start/Stop links (green to start, red to stop) def self.highlighted_links settings['highlighted_links'].to_s == '1' diff --git a/lib/stopwatch/issue_patch.rb b/lib/stopwatch/issue_patch.rb new file mode 100644 index 0000000..f2933dd --- /dev/null +++ b/lib/stopwatch/issue_patch.rb @@ -0,0 +1,26 @@ +module Stopwatch + # When an issue is closed, stop any timer still running on it, so the time logged on the issue is + # final before anything uses it (e.g. billing that runs when an issue closes). Otherwise the timer + # would keep adding hours to an entry that was already billed. + module IssuePatch + extend ActiveSupport::Concern + + prepended do + after_save :stop_timers_on_close, if: -> { saved_change_to_status_id? && closed? } + end + + def stop_timers_on_close + user_ids = time_entries.distinct.pluck(:user_id) + User.where(id: user_ids).find_each do |user| + timer = Stopwatch::Timer.new(user) + next unless timer.running? && timer.time_entry&.issue_id == id + + timer.stop + Rails.logger.info "[Stopwatch] Stopped user ##{user.id}'s timer because issue ##{id} was closed" + end + rescue StandardError => e + # Never block closing the issue + Rails.logger.error "[Stopwatch] Could not stop timers for issue ##{id}: #{e.class}: #{e.message}" + end + end +end diff --git a/lib/stopwatch/time_entry_patch.rb b/lib/stopwatch/time_entry_patch.rb index f576d89..0ef545f 100644 --- a/lib/stopwatch/time_entry_patch.rb +++ b/lib/stopwatch/time_entry_patch.rb @@ -6,9 +6,10 @@ module Stopwatch before_destroy :stop_timer end + # Stop the user's timer only if it is running on this entry (deleting another entry used to stop it) def stop_timer t = Stopwatch::Timer.new(user) - t.update(stop: true) if t.running? + t.update(stop: true) if t.running? && t.time_entry_id == id end end end diff --git a/lib/stopwatch/timer.rb b/lib/stopwatch/timer.rb index ccc64f2..55ea241 100644 --- a/lib/stopwatch/timer.rb +++ b/lib/stopwatch/timer.rb @@ -1,8 +1,13 @@ require 'json' +require 'securerandom' module Stopwatch + # A user's running timer. Stored as JSON in the user's preferences: + # started_at - when time was last saved into the time entry (nil when stopped) + # time_entry_id - the time entry the timer adds to + # session_hours - hours already added since the timer was started, for the maximum timer length + # tick_token - identifies this start's chain of server-side saves (StopwatchTimerTickJob) class Timer - class HourFormatter include ApplicationHelper @@ -19,7 +24,6 @@ module Stopwatch end end - attr_reader :user def initialize(user) @@ -30,29 +34,52 @@ module Stopwatch data[:started_at].present? end + # Starts the timer on time_entry. If a timer is already running (e.g. after a double click), its + # time is saved and the timer moves to the new entry, instead of failing. def start(time_entry = nil) - fail "timer is already running" if running? - data[:started_at] = Time.now.to_i - data[:time_entry_id] = time_entry.id if time_entry - save + token = SecureRandom.hex(8) + locked do + apply_elapsed_time(stop: true) if running? + data[:started_at] = Time.now.to_i + data[:session_hours] = 0.0 + data[:time_entry_id] = time_entry&.id + data[:tick_token] = token + save + end + # Keep saving the time on the server every minute while it runs + StopwatchTimerTickJob.schedule(user.id, token) end def stop update stop: true end - # saves currently logged time to the time entry and resets the started_at - # timestamp to either nil (stop: true) or current time. + # Saves the time elapsed since the last save into the time entry, then stops the timer + # (stop: true) or keeps it running from now. The timer record is locked meanwhile, so two requests + # at the same moment (e.g. two open tabs) can't add the same time twice. Once a timer reaches the + # maximum timer length it is stopped at the limit and the entry's comment says so. def update(stop: false) - if hours = runtime_hours and entry = self.time_entry - time_entry.update_column :hours, entry.read_attribute(:hours) + hours + locked do + if running? + apply_elapsed_time(stop: stop) + save + end end - data[:started_at] = stop || !running? ? nil : Time.now.to_i - save end + def tick_token + data[:tick_token] + end + + # True when the running timer has reached the maximum timer length and should be stopped + def over_limit? + max = Stopwatch.max_timer_hours + running? && max.present? && data[:session_hours].to_f + (runtime_hours || 0) >= max + end + + # Hours to display: what's saved on the entry plus the running time (never beyond the limit) def time_spent - h = runtime_hours || 0 + h = unsaved_hours if e = time_entry h += e.hours end @@ -89,12 +116,59 @@ module Stopwatch @data ||= (t = user.pref[:current_timer]) ? JSON.parse(t).symbolize_keys : {} end + # Runs the block with the user's preference row locked, after re-reading the saved timer + def locked + pref = user.pref + pref.save! if pref.new_record? + pref.with_lock do + @data = nil + yield + end + end + + # Running time not yet saved into the entry, limited by the maximum timer length + def unsaved_hours + hours = runtime_hours || 0 + max = Stopwatch.max_timer_hours + max ? [hours, [max - data[:session_hours].to_f, 0].max].min : hours + end + + def apply_elapsed_time(stop:) + hours = unsaved_hours + capped = over_limit? + entry = time_entry + + if entry && (hours.positive? || capped) + attributes = {} + attributes[:hours] = entry.read_attribute(:hours).to_f + hours if hours.positive? + attributes[:comments] = capped_comment(entry) if capped + entry.update_columns(attributes) if attributes.any? + end + + if stop || capped + Rails.logger.info "[Stopwatch] Timer for user ##{user.id} stopped at the #{Stopwatch.max_timer_hours}h limit" if capped + data[:started_at] = nil + data[:session_hours] = 0.0 + else + data[:started_at] = Time.now.to_i + data[:session_hours] = data[:session_hours].to_f + hours + end + end + + # Notes on the entry that the timer hit the limit, so someone can correct the hours + def capped_comment(entry) + note = I18n.t(:text_stopwatch_timer_capped, hours: Stopwatch.max_timer_hours.to_s.sub(/\.0\z/, '')) + comments = entry.comments.to_s + return comments if comments.include?(note) + + [comments.presence, note].compact.join(' ').truncate(1024) + end + def runtime_hours if start = data[:started_at] runtime = Time.now.to_i - start return runtime.to_f / 1.hour end end - end end diff --git a/test/integration/ticket_timer_test.rb b/test/integration/ticket_timer_test.rb index 0f7c4f5..b659824 100644 --- a/test/integration/ticket_timer_test.rb +++ b/test/integration/ticket_timer_test.rb @@ -73,6 +73,19 @@ class TicketTimerTest < Redmine::IntegrationTest assert_not_running end + test "should not start a timer on an issue the user cannot see" do + log_user 'jsmith', 'jsmith' + post "/issues/999999/timer/start", xhr: true + assert_response 404 + end + + test "should offer start tracking in the issue context menu" do + log_user 'jsmith', 'jsmith' + get "/issues/context_menu", params: { ids: [@issue.id] }, xhr: true + assert_response :success + assert_select "a.stopwatch_issue_timer", text: /start tracking/i + end + test "should ask by default" do log_user 'jsmith', 'jsmith' TimeEntry.delete_all diff --git a/test/unit/issue_close_test.rb b/test/unit/issue_close_test.rb new file mode 100644 index 0000000..1211630 --- /dev/null +++ b/test/unit/issue_close_test.rb @@ -0,0 +1,42 @@ +require File.expand_path('../../test_helper', __FILE__) + +class IssueCloseTest < ActiveSupport::TestCase + fixtures :projects, :users, :user_preferences, :roles, :members, :member_roles, + :trackers, :projects_trackers, :enabled_modules, :issue_statuses, :issues, + :enumerations, :time_entries + + setup do + @user = User.find 2 + @issue = Issue.find 1 + @time_entry = TimeEntry.create!(project: @issue.project, issue: @issue, user: @user, author: @user, + spent_on: Date.today, hours: 1, activity: TimeEntryActivity.first) + @timer = Stopwatch::Timer.new(@user) + @timer.start @time_entry + data = @timer.send(:data) + data[:started_at] = 1.hour.ago.to_i + @timer.save + end + + test "closing an issue stops a timer running on it and saves the time" do + @issue.status = IssueStatus.where(is_closed: true).first + @issue.save! + + refute Stopwatch::Timer.new(User.find(@user.id)).running? + assert_in_delta 2, @time_entry.reload.hours, 0.01 + end + + test "other changes to the issue leave the timer running" do + @issue.subject = 'Renamed' + @issue.save! + + assert Stopwatch::Timer.new(User.find(@user.id)).running? + end + + test "deleting another time entry leaves the timer running" do + other = TimeEntry.create!(project: @issue.project, issue: @issue, user: @user, author: @user, + spent_on: Date.today, hours: 1, activity: TimeEntryActivity.first) + other.destroy + + assert Stopwatch::Timer.new(User.find(@user.id)).running? + end +end diff --git a/test/unit/timer_test.rb b/test/unit/timer_test.rb index f05fca6..fbadd45 100644 --- a/test/unit/timer_test.rb +++ b/test/unit/timer_test.rb @@ -1,53 +1,68 @@ require File.expand_path('../../test_helper', __FILE__) class TimerTest < ActiveSupport::TestCase + include ActiveJob::TestHelper + fixtures :users, :user_preferences, :time_entries setup do @user = User.find 1 @timer = Stopwatch::Timer.new @user - @data = @timer.send :data @time_entry = TimeEntry.last + @time_entry.update_column :comments, 'work' + Setting.plugin_stopwatch = Setting.plugin_stopwatch.merge('max_timer_hours' => '10') + end + + # The timer re-reads its saved state under a lock, so always look at the current data + def data + @timer.send :data + end + + # Pretend the timer was last saved `ago` seconds ago + def started(ago) + data[:started_at] = ago.ago.to_i + @timer.save end test "should know wether its running" do refute @timer.running? - @data[:started_at] = 5.minutes.ago + data[:started_at] = 5.minutes.ago assert @timer.running? end test "should start timer" do - assert_nil @data[:started_at] + assert_nil data[:started_at] @timer.start @time_entry - assert @data[:started_at].present? - assert_equal @time_entry.id, @data[:time_entry_id] + assert data[:started_at].present? + assert_equal @time_entry.id, data[:time_entry_id] end test "should stop timer and update time entry" do hours = @time_entry.hours @timer.start @time_entry - @data[:started_at] = 1.hour.ago.to_i + started 1.hour @timer.stop @time_entry.reload assert_equal hours + 1, @time_entry.hours + refute @timer.running? end test "should update time entry" do hours = @time_entry.hours @timer.start @time_entry - @data[:started_at] = 1.hour.ago.to_i + started 1.hour @timer.update @time_entry.reload assert_equal hours + 1, @time_entry.hours - end + assert @timer.running? + end test "should save and restore" do hours = @time_entry.hours @timer.start @time_entry - @data[:started_at] = 1.hour.ago.to_i - @timer.save + started 1.hour timer = Stopwatch::Timer.new User.find(@user.id) assert timer.running? @@ -57,6 +72,100 @@ class TimerTest < ActiveSupport::TestCase assert_equal hours + 1, @time_entry.hours end + test "should not add the same time twice when updated twice" do + hours = @time_entry.hours + @timer.start @time_entry + started 1.hour + # e.g. two open tabs checking the timer at the same moment + other_tab = Stopwatch::Timer.new User.find(@user.id) + @timer.update + other_tab.update + + @time_entry.reload + assert_in_delta hours + 1, @time_entry.hours, 0.01 + end + + test "should stop a forgotten timer at the limit and flag the entry" do + Setting.plugin_stopwatch = Setting.plugin_stopwatch.merge('max_timer_hours' => '2') + hours = @time_entry.hours + @timer.start @time_entry + started 60.hours # left running over a weekend + @timer.stop + + @time_entry.reload + assert_equal hours + 2, @time_entry.hours + assert_includes @time_entry.comments, 'work' + assert_includes @time_entry.comments, '2 hour limit' + refute @timer.running? + end + + test "should count earlier saves toward the limit" do + Setting.plugin_stopwatch = Setting.plugin_stopwatch.merge('max_timer_hours' => '2') + hours = @time_entry.hours + @timer.start @time_entry + started 90.minutes + @timer.update + assert @timer.running? + + started 1.hour + @timer.update + + @time_entry.reload + assert_in_delta hours + 2, @time_entry.hours, 0.01 + refute @timer.running? + end + + test "should not limit timers when the limit is blank" do + Setting.plugin_stopwatch = Setting.plugin_stopwatch.merge('max_timer_hours' => '') + hours = @time_entry.hours + @timer.start @time_entry + started 30.hours + @timer.stop + + @time_entry.reload + assert_in_delta hours + 30, @time_entry.hours, 0.01 + end + + test "starting again moves the timer instead of failing" do + other_entry = TimeEntry.where.not(id: @time_entry.id).first + hours = @time_entry.hours + @timer.start @time_entry + started 1.hour + + @timer.start other_entry # e.g. a double click, or starting another entry + + assert_equal other_entry.id, data[:time_entry_id] + assert_in_delta hours + 1, @time_entry.reload.hours, 0.01 + end + + test "should schedule server-side saves while running" do + assert_enqueued_with(job: StopwatchTimerTickJob) do + @timer.start @time_entry + end + end + + test "tick job saves the time and schedules the next tick" do + hours = @time_entry.hours + @timer.start @time_entry + started 1.hour + token = data[:tick_token] + + clear_enqueued_jobs + assert_enqueued_with(job: StopwatchTimerTickJob, args: [@user.id, token]) do + StopwatchTimerTickJob.perform_now(@user.id, token) + end + assert_in_delta hours + 1, @time_entry.reload.hours, 0.01 + end + + test "tick job from an earlier start does nothing" do + hours = @time_entry.hours + @timer.start @time_entry + started 1.hour + + clear_enqueued_jobs + StopwatchTimerTickJob.perform_now(@user.id, 'old-token') + assert_no_enqueued_jobs + assert_equal hours, @time_entry.reload.hours + end end -