How to compre DateTime with generic times in ruby - ruby-on-rails

Question

I'm working on a ruby on rails app that can automatically schedule events. Every event has a start_time datetime and an end_time datetime.
Here is the problem:
In general, events shouldn't be scheduled before 9:00am or after 10:30pm. This is true for edge cases as well. I.e, even if an event ends after 9:00am, it shouldn't start before it. Similarly, if an event starts before 10:30pm, it should not go on passed 10:30pm.
How can I go about making sure that every event fits this criteria, when some of these events are on different dates?
The problem i'm having is that, yes, a DateTime object has a date and a time associated with it. But so does a Time object.
This means that if I have an event with a start and end datetime between 9am and 10:30pm, my comparison will always return false if I'm comparing a time object with a datetime object of a different date.
Here is what I had in mind:
def event_out_of_bounds?(event_start_time, event_end_time, min_start_time, max_end_time)
if event_start_time.hour > max_end_time.hour then
return true
end
if event_end_time.hour > max_end_time.hour then
return true
end
if event_start_time.hour < min_start_time.hour then
return true
end
if event_end_time.hour < min_start_time.hour then
return true
end
return false
end
Problems with this code:
It doesn't take into account minutes. I.e., if I ever change min_start_time to 9:30 am, then this method won't work anymore.
There are different dates involved. event_start_time and event_end_time, which are DateTimes, obviously have the same date. However, min_start_time and max_end_time, Which are created using Time.new have a different date (I just default it 2020-01-01). This wouldn't be a big problem if I knew beforehand what the dates would be for the events, however I won't in this case.
Any ideas for an algorithm to make this check elegantly?

Answer 1

events shouldn't be scheduled before 9:00am or after 10:30pm.
I might use Range#cover? for this.
require 'active_support/all'
def validate_schedule(s, e)
min = s.time_zone.local(s.year, s.month, s.day, 9, 0, 0)
max = s.time_zone.local(s.year, s.month, s.day, 22, 30, 0)
(min..max).cover?(s..e)
end
# Tests
et = ActiveSupport::TimeZone.new('Eastern Time (US & Canada)')
t = ->(d, h, m) { et.local(2020, 2, d, h, m, 0) }
test = ->(s, e) { puts format('%s %s = %s', s, e, validate_schedule(s, e)) }
test[t[1, 8, 59], t[1, 22, 30]] # false, start too early
test[t[1, 9, 0], t[1, 22, 30]] # true, 10:30 pm ok
test[t[1, 9, 0], t[1, 21, 30]] # true, 9:30 pm also ok
test[t[1, 9, 0], t[1, 22, 31]] # false, end too late
test[t[1, 9, 0], t[2, 22, 30]] # false, no all night parties
If you allow multi-day events, simply calculate max from the end date (e) instead:
max = e.time_zone.local(e.year, e.month, e.day, 22, 30, 0)
Range.cover? works with "any objects that can be compared using the <=> operator." (see Custom Objects in Ranges

Answer 2

Approach
It's curious that the question is framed in terms of DateTime objects, considering that the underlying problem seems to be just determining whether the scheduled time of a sporting match falls within a given window of time. Using DateTime objects is but one way of addressing the problem, but is not the only way. In that sense the question may fall under the heading of X-Y problem.
In fact, I find the use of DateTime objects complicates the problem unnecessarily. It's easier to express each time as simply a two-element array that contains the hour and minute. For example, the time-window that extends from 12:30 (24-hour clock) to 22:00 that evening could be expressed as the range:1
window = [12, 30]..[22, 0]
Event times could be defined similarly:2
event_time = [15, 45]..[19, 30]
For convenience, I will refer to the two-element arrays that are the endpoints of these ranges as simply "times".
An important consideration is that the start and end time of a sporting event does not necessarily fall on the same day. An example would be a tournament at which matches must fall within a window between 12:30 (24 hour clock) and 1:00 (AM) the following day. This is not unusual. This time-window would be expressed:
window = [12, 30]..[1, 0]
I assume:
end times are less than 24 hours after their corresponding start times; and
the time-window is the same every day.
Adjustments could of course be made to the code below if either assumption does not hold.
Code
Let's construct a method valid? that returns true (else false) if a given event falls within a given time-window:
def valid?(event_time, window)
e = time_to_mins(event_time.begin)..time_to_mins(event_time.end)
w = time_to_mins(window.begin)..time_to_mins(window.end)
if w.begin <= w.end
w.cover?(e)
else
(w.begin <= e.begin || e.begin <= w.end) &&
(w.begin <= e.end || e.end <= w.end)
end
end
def time_to_mins(time_arr)
60 * time_arr.first + time_arr.last
end
Examples
time_to_mins [ 0, 10] #=> 10
time_to_mins [22, 30] #=> 1350
window = [ 9, 30]..[22, 30]
valid?([13, 45]..[16, 30], window) #=> true
valid?([ 8, 45]..[11, 30], window) #=> false
valid?([22, 15]..[ 0, 15], window) #=> false
window = [12, 30]..[1, 0]
valid?([16, 15]..[19, 30], window) #=> true
valid?([22, 45]..[ 0, 30], window) #=> true
valid?([ 0, 15]..[ 0, 45], window) #=> true
valid?([22, 45]..[ 1, 30], window) #=> false
valid?([ 0, 15]..[ 1, 45], window) #=> false
1. If desired, one might alternatively express times as hashes, such as { hour: 12, min: 30, sec: 0 }.
2. Information for each event might be held in a larger data structure, such as event = { start_date: [2020, 2, 7], time_block: [[22, 45, 0]..[ 0, 30, 0]], player_1: 'R. Federer', player_2: 'R. Nadal' }, using only event[:time_block] in the above calculation.