Count working hours between two datetimes in Ruby - ruby-on-rails

Question

I want to count "morning" and "evening" working hours between two datetimes in Ruby.
"Morning" working hours starts at 06:00:00 and ends at 21:59:59
"Evening" working hours starts at 22:00:00 and ends at 05:59:59
For example, employee started work at 2014-06-04 21:45 and completed at 2014-06-05 05:45, it means, in summary should be:
0.25 "morning" working hours
7.75 "evening" working hours
Total 8 working hours

Answer 1

This could be done using the biz gem:
morning_schedule = Biz::Schedule.new do |config|
config.hours = {
mon: {'06:00' => '22:00'},
tue: {'06:00' => '22:00'},
wed: {'06:00' => '22:00'},
thu: {'06:00' => '22:00'},
fri: {'06:00' => '22:00'}
}
end
evening_schedule = Biz::Schedule.new do |config|
config.hours = {
mon: {'00:00' => '06:00', '22:00' => '24:00'},
tue: {'00:00' => '06:00', '22:00' => '24:00'},
wed: {'00:00' => '06:00', '22:00' => '24:00'},
thu: {'00:00' => '06:00', '22:00' => '24:00'},
fri: {'00:00' => '06:00', '22:00' => '24:00'}
}
end
# morning hours worked
morning_schedule.within(
Time.new(2014, 6, 4, 21, 45),
Time.new(2014, 6, 5, 5, 45)
)
# evening hours worked
evening_schedule.within(
Time.new(2014, 6, 4, 21, 45),
Time.new(2014, 6, 5, 5, 45)
)
With the duration of each working time type determined, subsequent calculations, such as with salary coefficients, can be performed.

Answer 2

You can use the working_hours gem that does this kind of computing : https://github.com/intrepidd/working_hours

Answer 3

Here's an ugly implementation (should work for any range of time):
def time_test(tstr1, tstr2)
t1 = Time.parse(tstr1)
t2 = Time.parse(tstr2)
morning_seconds = 0
evening_seconds = 0
while t1 < t2 do
# if we are starting during morning hours...
if t1.hour >= 6 && t1.hour < 22
# this sets the end of morning hours for the current day...
tend = t1.change(hour: 22)
# but our actual morning_end should be the lesser of the range end time
# and the end of current days' working hours
morning_end = tend < t2 ? tend : t2
# increment our seconds with the difference between start time and morning end
morning_seconds += morning_end - t1
# set our start time to morning_end. if morning_end == t2, then we'll exit
# the while loop, else we'll process some evening hours
t1 = morning_end
# if we are starting during evening hours (at end of day)
elsif t1.hour >= 22
# same as above, except that the potential end time needs to increment the day
# as well as the hour
tend = t1.tomorrow.change(hour: 6)
evening_end = tend < t2 ? tend : t2
evening_seconds += evening_end - t1
t1 = evening_end
# if we are starting during evening hours (at beginning of day)
elsif t1.hour < 6
tend = t1.change(hour: 6)
evening_end = tend < t2 ? tend : t2
evening_seconds += evening_end - t1
t1 = evening_end
end
end
{
morning: morning_seconds / 3600,
evening: evening_seconds / 3600,
total: (morning_seconds + evening_seconds) / 3600
}
end
time_test('2014-06-04 21:45', '2014-06-05 05:45')
# => {:morning=>0.25, :evening=>7.75, :total=>8.0}
And here is a slightly prettier recursive way:
def time_test(tstr1, tstr2)
_t1 = Time.parse(tstr1)
t2 = Time.parse(tstr2)
runner = lambda do |t1, ms, es|
return {
morning: ms / 3600, evening: es / 3600, total: (ms + es) / 3600
} if t1 >= t2
if t1.hour >= 6 && t1.hour < 22
tend = t1.change(hour: 22)
morning_end = tend < t2 ? tend : t2
runner.call(morning_end, ms + (morning_end - t1), es)
elsif t1.hour >= 22
tend = t1.tomorrow.change(hour: 6)
evening_end = tend < t2 ? tend : t2
runner.call(evening_end, ms, es + (evening_end - t1))
elsif t1.hour < 6
tend = t1.change(hour: 6)
evening_end = tend < t2 ? tend : t2
runner.call(evening_end, ms, es + (evening_end - t1))
end
end
runner.call(_t1, 0, 0)
end