def _check_border_range(self,
border_range_datetime: RangeDateTime) -> bool:
if not self.covers_a_whole_day():
starting_date = border_range_datetime.starting_datetime.date()
previous_date = starting_date - timedelta(days=1)
current_date = starting_date
range_datetime = self._build_example_from_date(previous_date)
if range_datetime:
if RangeDateTimeOperator.is_in(border_range_datetime,
range_datetime):
return True
range_datetime = self._build_example_from_date(current_date)
if range_datetime:
if RangeDateTimeOperator.is_in(border_range_datetime,
range_datetime):
return True
else:
range_datetime = self.get_as_a_range_datetime()
if RangeDateTimeOperator.is_in(border_range_datetime,
range_datetime):
return True
return False
def test_are_intersection3(self):
r1 = RangeDateTime(datetime(2019, 5, 1, 10, 0, 0),
datetime(2019, 5, 4, 10, 0, 0))
r2 = RangeDateTime(datetime(2019, 5, 4, 10, 0, 1),
datetime(2019, 5, 5, 10, 0, 0))
assert not RangeDateTimeOperator.are_intersection(r1, r2)
def check_next_collision(self, main_day, next_day):
main_range = self.day_to_range_datetime(main_day, CURRENT)
next_range = self.day_to_range_datetime(next_day, NEXT)
intersection = RangeDateTimeOperator.get_intersection(
main_range, next_range)
if intersection:
return intersection
else:
return None
def check_prev_collision(self, main_day, prev_day):
main_range = self.day_to_range_datetime(main_day, CURRENT)
prev_range = self.day_to_range_datetime(prev_day, PREVIOUS)
intersection = RangeDateTimeOperator.get_intersection(
main_range, prev_range)
if intersection:
return intersection
else:
return None
def check_current_collision(self, main_day: Any,
current_day: Any) -> Optional[RangeDateTime]:
main_range = self.day_to_range_datetime(main_day, CURRENT)
current_range = self.day_to_range_datetime(current_day, CURRENT)
intersection = RangeDateTimeOperator.get_intersection(
main_range, current_range)
if intersection:
return intersection
else:
return None
def test_split_borders_4(self):
range_datetime = RangeDateTime(datetime(2019, 5, 1, 10, 0, 0),
datetime(2019, 5, 1, 10, 0, 0))
response = RangeDateTimeOperator.split_borders(range_datetime)
expected = [
RangeDateTime(datetime(2019, 5, 1, 10, 0, 0),
datetime(2019, 5, 1, 10, 0, 0)),
None,
None,
]
assert response == expected
def check_current_colision(
self, current_day_name: str,
main_range: RangeDateTime) -> Optional[RangeDateTime]:
current_range = self.weekly_facade.range_datetime_obj_from_day_number(
current_day_name, self.base_current_date)
if not current_range:
return None
intersection = RangeDateTimeOperator.get_intersection(
current_range, main_range)
if intersection:
return intersection
else:
return None
def check_prev_collision(
self, manually_range: RangeDateTime,
weekly_day: Any) -> Tuple[Optional[int], Optional[RangeDateTime]]:
prev_weekly_day = self.weekly_facade.get_prev_day(weekly_day)
weekly_prev_range = self.weekly_facade.range_datetime_from_weekly_day(
prev_weekly_day, self.base_prev_date)
if weekly_prev_range:
intersection = RangeDateTimeOperator.get_intersection(
weekly_prev_range, manually_range)
if intersection:
return (prev_weekly_day.day_number, intersection)
else:
return (None, None)
else:
return (None, None)
def test_split_borders_1(self):
range_datetime = RangeDateTime(datetime(2019, 5, 1, 10, 0, 0),
datetime(2019, 5, 4, 10, 0, 0))
response = RangeDateTimeOperator.split_borders(range_datetime)
expected = [
RangeDateTime(datetime(2019, 5, 1, 10, 0, 0),
datetime(2019, 5, 1, 23, 59, 0)),
Range(datetime(2019, 5, 2).date(),
datetime(2019, 5, 3).date()),
RangeDateTime(datetime(2019, 5, 4, 0, 0, 0),
datetime(2019, 5, 4, 10, 0, 0)),
]
assert response == expected
def check_current_collision(self, manually_day: Any,
cycle_day: Any) -> Optional[RangeDateTime]:
current_range = self.cycle_facade.range_datetime_obj_from_day_number(
cycle_day, self.base_current_date)
manually_range = self.manually_facade.range_datetime_obj_from_day(
manually_day, self.base_current_date)
if current_range and manually_range:
intersection = RangeDateTimeOperator.get_intersection(
current_range, manually_range)
if intersection:
return intersection
else:
return None
else:
return None
def check_current_collision(
self, manually_range: RangeDateTime,
weekly_day: Any) -> Tuple[Optional[int], Optional[RangeDateTime]]:
weekly_current_range = self.weekly_facade\
.range_datetime_from_weekly_day(
weekly_day,
self.base_current_date
)
if weekly_current_range:
intersection = RangeDateTimeOperator.get_intersection(
weekly_current_range, manually_range)
if intersection:
return weekly_day.day_number, intersection
else:
return None, None
else:
return None, None
def is_in(self, range_datetime):
split_data = RangeDateTimeOperator.split_borders(range_datetime)
left_range_datetime = split_data[0]
body = split_data[1]
right_range_datetime = split_data[2]
left_response = True
if left_range_datetime:
left_response = self._check_border_range(left_range_datetime)
right_response = True
if right_range_datetime:
right_response = self._check_border_range(right_range_datetime)
body_response = True
if body:
body_response = self._check_body(body)
return left_response and right_response and body_response
def test_are_intersection1(self):
r1 = RangeDateTime(datetime(2019, 5, 1), datetime(2019, 5, 4))
r2 = RangeDateTime(datetime(2019, 5, 3), datetime(2019, 5, 5))
assert RangeDateTimeOperator.are_intersection(r1, r2)