def process_exception_list(temp_exceptions):
new_temp_exceptions = [[] for _ in range(len(temp_exceptions))]
for i in range(0, len(temp_exceptions)):
print("--new i---")
for j in range(0, len(temp_exceptions[i])):
if j == 0:
new_temp_exceptions[i].append(temp_exceptions[i][j])
else:
no_intersection = True
for k in range(0, len(new_temp_exceptions[i])):
date_range1 = DateTimeRange(
str(temp_exceptions[i][j][0:19]),
str(temp_exceptions[i][j][22:41]))
date_range2 = DateTimeRange(
str(new_temp_exceptions[i][k][0:19]),
str(new_temp_exceptions[i][k][22:41]))
if date_range1.is_intersection(date_range2):
new_range = date_range1.intersection(date_range2)
new_temp_exceptions[i][k] = str(new_range).replace(
"T", " ")
no_intersection = False
if no_intersection:
new_temp_exceptions[i].append(temp_exceptions[i][j])
for i in range(0, len(new_temp_exceptions)):
for j in range(0, len(new_temp_exceptions[i])):
if str(new_temp_exceptions[i][j][0:19]) == str(
new_temp_exceptions[i][j][22:41]):
new_temp_exceptions[i].remove(new_temp_exceptions[i][j])
return new_temp_exceptions
def parseIbHours(ibHours, tz):
if not isinstance(ibHours, str):
fatal.errorAndExit('trading hours is a string')
openHours = []
# '20200427:0930-20200427:1600;20200428:0930-20200428:1600'
ranges = ibHours.split(';')
m = re.compile('.*:CLOSED')
for range_ in ranges:
if range_ == '':
continue
if m.match(range_): # skip closed days
continue
ts = range_.split('-')
if len(ts) != 2:
fatal.errorAndExit(
'only two timestamps per range: {} {}'.format(ts, ibHours))
start = tz.localize(datetime.strptime(
ts[0], '%Y%m%d:%H%M')).astimezone(pytz.utc)
end = tz.localize(datetime.strptime(ts[1], '%Y%m%d:%H%M')).astimezone(
pytz.utc)
r = DateTimeRange(start, end)
if not r.is_valid_timerange():
fatal.errorAndExit('should get a valid timerange')
openHours.append(r)
logging.debug('openHours: %s', openHours)
return openHours
def configure_and_execute_overlap_test(self, schedule_get_all_mock,
start_reprocess_time,
end_reprocess_time):
self.configure_schedules_mock(schedule_get_all_mock,
start_reprocess_time, end_reprocess_time)
scheduling_range = DateTimeRange(
tzutils.utc_to_local(self.start_reprocess_time),
tzutils.utc_to_local(self.end_reprocess_time))
scheduled_range = DateTimeRange(
tzutils.local_to_utc(start_reprocess_time),
tzutils.local_to_utc(end_reprocess_time))
expected_message = \
"400 Bad Request: Cannot schedule a reprocessing for scope " \
"[toStringMock] for reprocessing time [%s], because it already " \
"has a schedule for a similar time range [%s]." \
% (scheduling_range, scheduled_range)
expected_message = re.escape(expected_message)
self.assertRaisesRegex(
http_exceptions.BadRequest, expected_message,
self.endpoint.validate_reprocessing_schedules_overlaps,
self.generate_all_scopes_object(), self.end_reprocess_time,
self.start_reprocess_time)
schedule_get_all_mock.assert_called_with(
identifier=[self.scope_ids[0]])
def hours_validator(period):
""" Validates that the received time period is in the
following format: `'HH:MM-HH:MM'`
"""
time_points = period.split('-')
if len(time_points) != 2:
error = "Working hours period should be separated by '-'"
raise ValidationError(error)
for time in time_points:
time_check = time.split(':')
if len(time_check) != 2:
raise ValidationError('Time format is not HH:MM')
if int(time_check[0]) not in range(0, 24) or \
int(time_check[1]) not in range(0, 60):
raise ValidationError('Time format is not HH:MM')
# Checks whether there is no time inversion in the input range
today = date.today()
range_start = datetime.strptime(time_points[0], '%H:%M').time()
range_end = datetime.strptime(time_points[1], '%H:%M').time()
range_start_dt = datetime.combine(today, range_start)
range_end_dt = datetime.combine(today, range_end)
output_range = DateTimeRange(range_start_dt, range_end_dt)
try:
output_range.validate_time_inversion()
except ValueError:
raise ValidationError(f'Time inversion identified: "{period}"')
def check_if_rent_is_possible(centre_id,
gear_id,
rent_amount,
rent_start,
rent_end,
max_rent,
session=None):
rent_start = datetime.datetime.strptime(rent_start,
'%Y-%m-%dT%H:%M:%S.%fZ')
rent_end = datetime.datetime.strptime(rent_end, '%Y-%m-%dT%H:%M:%S.%fZ')
all_rents = session.query(GearRental).filter_by(
centre_id=centre_id,
gear_id=gear_id).filter(GearRental.rent_end > rent_start,
GearRental.rent_start < rent_end,
GearRental.rent_status != -1).all()
iter_start = rent_start
while iter_start <= rent_end:
total_number_of_rented_gear = 0
iter_start_with_delta = iter_start + datetime.timedelta(minutes=15)
timerange = DateTimeRange(iter_start, iter_start_with_delta)
for rent in all_rents:
rent_time_range = DateTimeRange(rent.rent_start, rent.rent_end)
if timerange.intersection(rent_time_range):
total_number_of_rented_gear += rent.rent_amount
if total_number_of_rented_gear + rent_amount > max_rent:
return False
iter_start = iter_start_with_delta
return True
def is_cache_available(self, cache_file_path):
if not cache_file_path.isfile():
logger.debug("cache not found: {}".format(cache_file_path))
return False
try:
dtr = DateTimeRange(datetime.fromtimestamp(cache_file_path.mtime),
datetime.now())
except OSError:
return False
if not dtr.is_valid_timerange():
return False
cache_elapsed = CacheTime(dtr.get_timedelta_second())
cache_msg = "path={path}, lifetime={lifetime:.1f}h, elapsed={elapsed:.1f}h".format(
path=cache_file_path,
lifetime=self.__cache_lifetime.hour,
elapsed=cache_elapsed.hour)
if cache_elapsed < self.__cache_lifetime:
logger.debug("cache available: {}".format(cache_msg))
return True
logger.debug("cache expired: {}".format(cache_msg))
return False
class TestDateTimeRange_truncate:
@pytest.mark.parametrize(
["value", "expected"],
[
[0, DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME)],
[
10,
DateTimeRange("2015-03-22 10:00:30" + TIMEZONE,
"2015-03-22 10:09:30" + TIMEZONE)
],
],
)
def test_normal(self, datetimerange_normal, value, expected):
datetimerange_normal.truncate(value)
assert datetimerange_normal == expected
@pytest.mark.parametrize(["value", "expected"], [[-10, ValueError]])
def test_exception(self, datetimerange_normal, value, expected):
with pytest.raises(expected):
datetimerange_normal.truncate(value)
@pytest.mark.parametrize(["value"], [[10]])
def test_null(self, datetimerange_null_start, value):
with pytest.raises(TypeError):
datetimerange_null_start.truncate(value)
def test_change_record_data():
start_datetime = datetime.datetime(year=2020, month=1, day=1)
schedule = Schedule(start_datetime, duration=3600)
_range = DateTimeRange(start_datetime,
start_datetime + datetime.timedelta(minutes=1))
assert schedule.add_record('OLD TYPE', _range)
assert len(schedule.records) == 1
assert 'data' in schedule.records[-1]
assert schedule.records[-1]['data'] is None
existed_record = schedule.records[-1]
new_range = DateTimeRange(start_datetime,
start_datetime + datetime.timedelta(minutes=2))
new_record = {
'type': 'NEW TYPE',
'range': new_range,
'data': {
'key': 'val'
}
}
assert schedule.change_record(existed_record, new_record)
assert 'data' in schedule.records[-1]
assert schedule.records[-1]['data'] == {'key': 'val'}
def test_normal(
self, start, start_format, end, end_format,
separator, is_output_elapse, expected):
dtr = DateTimeRange(start, end, start_format, end_format)
dtr.separator = separator
dtr.is_output_elapse = is_output_elapse
assert str(dtr) == expected
class TestDateTimeRange_set_time_range:
@pytest.mark.parametrize(
["start", "end", "expected"],
[
[
START_DATETIME_TEXT,
END_DATETIME_TEXT,
DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME),
],
[None, None, DateTimeRange(None, None)],
],
)
def test_normal(self, start, end, expected):
dtr = DateTimeRange()
dtr.set_time_range(start, end)
assert dtr == expected
@pytest.mark.parametrize(
["start", "end", "expected"],
[
["invalid time string", END_DATETIME_TEXT, ValueError],
[START_DATETIME_TEXT, "invalid time string", ValueError],
["invalid time string", "invalid time string", ValueError],
],
)
def test_exception(self, start, end, expected):
dtr = DateTimeRange()
with pytest.raises(expected):
dtr.set_time_range(start, end)
def horarios_futuros(self, data, solicitante):
quando = self.solicitacao_futura(solicitante)
if quando is not None:
inicio = localtime(quando.inicio).strftime('%d/%m/%Y às %H:%M')
raise Exception(
f"Você já tem uma solicitação prevista para {inicio} na situação {quando.status}"
)
if not (max(self.inicio, date.today()) <= data.date() <= self.fim):
raise Exception(
f"A data deve ser entre {self.inicio} e {self.fim}, mas você informou a data {data}."
)
result = []
for vaga in self.vaga_set.filter(dia=data.weekday()):
time_range = DateTimeRange(datetime.combine(data, vaga.inicio),
datetime.combine(data, vaga.fim))
for dt in time_range.range(timedelta(minutes=self.janela)):
if make_aware(dt) > now():
quantidade = Solicitacao.objects.filter(
agenda=self,
inicio=dt,
status__in=[
Solicitacao.Status.DEFERIDO,
Solicitacao.Status.SOLICITADO
]).count()
if quantidade < vaga.atendimentos:
result.append(dt)
return result[:-1]
class Test_DateTimeRange_hash(object):
@pytest.mark.parametrize(
["value", "expected"],
[
[
DateTimeRange("2015-03-22T10:00:00+0900",
"2015-03-22T10:10:00+0900"),
("2015-03-22T10:00:00+0900", "2015-03-22T10:10:00+0900"),
],
],
)
def test_normal(self, value, expected):
assert hash(value) == expected
@pytest.mark.parametrize(
["value", "expected"],
[
[
DateTimeRange(),
("NaT", "NaT"),
],
],
)
def test_null(self, value, expected):
assert hash(value) == expected
def clean(self):
cleaned_data = super().clean()
# get value
staff = cleaned_data.get('staff')
start_date = cleaned_data.get("start_date")
end_date = cleaned_data.get("end_date")
# check if start_date is before end_date else raise error
if start_date > end_date:
raise forms.ValidationError(
_('The start date must be before the end date.'),
code='invalid')
# create a range from form
form_absence_range = DateTimeRange(start_date, end_date)
# get absences
absences = Absence.objects.filter(
start_date__lte=end_date,
end_date__gte=start_date,
staff_id=staff.id).exclude(pk=self.instance.pk)
for absence in absences:
# create a range absence
absence_range = DateTimeRange(absence.start_date, absence.end_date)
# if form range is intersection with absence range raise error
if form_absence_range.is_intersection(absence_range):
raise forms.ValidationError(
_('An absence already exists on these dates.'),
code='invalid')
return cleaned_data
def merge_schedules(players: Dict[str, List[DateTimeRange]], required: int,
start: datetime) -> Dict[datetime, List[Set[str]]]:
"""Merge individual schedules to time slots where people are free.
Takes a mapping of people's availability and returns a mapping of
blocks of time (by the start time) to players free in that block.
E.g. if Jon is free at 12-2pm and Neel is free from 1-2pm and blocks
are 30 minutes, then return a dictionary of 4 times, with the first
2 time blocks mapping to (Jon) and the second two to (Jon, Neel).
"""
if not start:
start = datetime.now(timezone("Europe/London")).replace(minute=0,
second=0,
microsecond=0)
candidates = DateTimeRange(start, start + timedelta(days=14))
potentials = defaultdict(list)
for candidate_times in candidates.range(timedelta(minutes=MINUTES)):
candidate_players = []
for player, timeranges in players.items():
for timerange in timeranges:
if timerange.start_datetime <= candidate_times < timerange.end_datetime:
candidate_players.append(player)
for combination_length in range(required, len(candidate_players) + 1):
combos = combinations(candidate_players, combination_length)
potentials[candidate_times].extend(combos)
return potentials
def find_times(players: Dict[str, List[DateTimeRange]],
required: int,
start=None) -> Dict[FrozenSet[str], List[DateTimeRange]]:
schedules = merge_schedules(players, required, start)
potentials = defaultdict(list)
for viable_time, player_sets in schedules.items():
for player_set in player_sets:
current_players = frozenset(player_set)
if len(current_players) < required:
continue
if not potentials[current_players]:
potentials[current_players].append(DateTimeRange(viable_time))
current_time = potentials[current_players][-1]
if (viable_time - current_time.start_datetime
).total_seconds() <= MINUTES * 60:
current_time.set_end_datetime(viable_time)
elif (viable_time -
current_time.end_datetime).total_seconds() <= MINUTES * 60:
current_time.set_end_datetime(viable_time)
else:
potentials[current_players].append(DateTimeRange(viable_time))
for time_ranges in potentials.values():
for time_range in time_ranges:
time_range.set_end_datetime(time_range.end_datetime +
timedelta(minutes=MINUTES))
return potentials
def update_appointments(id:int):
print(f'{id}')
record_id = int(id)
record = Appointment.query.filter_by(id=record_id).first()
print(request.json)
if record:
date = request.json['date']
time_from = request.json['time_from']
time_to = request.json['time_to']
if date == '' or time_from == '' or time_to == '':
return jsonify(message='date and time cannot be blank'), 406
try:
date_time_from = datetime.datetime.strptime(f'{date}T{time_from}', '%Y-%m-%dT%H:%M:%S')
date_time_to = datetime.datetime.strptime(f'{date}T{time_to}', '%Y-%m-%dT%H:%M:%S')
except:
date_time_from = datetime.datetime.strptime(f'{date}T{time_from}', '%Y-%m-%dT%H:%M')
date_time_to = datetime.datetime.strptime(f'{date}T{time_to}', '%Y-%m-%dT%H:%M')
recieved_dates = DateTimeRange(f'{date}T{time_from}', f'{date}T{time_to}')
## any booking for the past dates or time cannot be accomodated.
if datetime.datetime.now() > date_time_from:
return jsonify(message='Any booking for the past dates or time cannot be accomodated'), 406
if date_time_from > date_time_to:
return jsonify(message='Any booking for the past dates or time cannot be accomodated'), 406
## booking are'nt allowed during sunday
if datetime.datetime.strptime(date, '%Y-%m-%d').weekday() == 6:
return jsonify(message='Sorry appointments are only allowed from Monday to Saturday'), 406
## bookings only allowed during opening-hourse
opening_hours = DateTimeRange(f'{date}T09:00', f'{date}T17:00')
if (recieved_dates in opening_hours) == False:
return jsonify(message='Appointments are only allowed from 9:00AM - 5:00PM'), 406
## check for conflicting booking records
success_message = 'You added a new record!'
datas = Appointment.query.all()
if datas:
for data in datas:
data_dates = DateTimeRange(str(data.date_time_from).replace(' ', 'T'),
str(data.date_time_to).replace(' ', 'T'))
if data_dates.is_intersection(recieved_dates):
if data.id != record_id:
return jsonify(message='There is a conflict between your schedule'), 409
## update records to the database
record.first_name = request.json['first_name']
record.last_name = request.json['last_name']
record.comments = request.json['comments']
record.date_time_from = date_time_from
record.date_time_to = date_time_to
db.session.commit()
return jsonify(message="You updated a record"), 202
else:
return jsonify(message="record cannot be found!"), 404
class TestDateTimeRange_add:
@pytest.mark.parametrize(
["value", "add_value", "expected"],
[
[
DateTimeRange("2015-03-22T10:00:00+0900",
"2015-03-22T10:10:00+0900"),
timedelta(seconds=10 * 60),
DateTimeRange("2015-03-22T10:10:00+0900",
"2015-03-22T10:20:00+0900"),
],
[
DateTimeRange("2015-03-22T10:00:00", "2015-03-22T10:10:00"),
timedelta(seconds=-10 * 60),
DateTimeRange("2015-03-22T09:50:00", "2015-03-22T10:00:00"),
],
],
)
def test_normal(self, value, add_value, expected):
new_datetimerange = value + add_value
assert new_datetimerange == expected
@pytest.mark.parametrize(
["value", "expected"],
[["2015-03-22T10:10:00+0900", TypeError], [1, TypeError],
[None, TypeError]],
)
def test_exception(self, datetimerange_normal, value, expected):
with pytest.raises(TypeError):
datetimerange_normal + value
def test_null(self, datetimerange_null):
with pytest.raises(TypeError):
datetimerange_null + timedelta(seconds=10 * 60)
def create(self, request, *args, **kwargs):
u = {'user': 1}
data = request.data
data.update(u)
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
# Get submitted dates and property id
startDate = self.request.data.get('startDate')
endDate = self.request.data.get('endDate')
propId = self.request.data.get('property')
# retrieve list of bookings for this property
bookingsList = self.queryset.filter(property_id=propId)
# Create date range from request
inserted_range = DateTimeRange(startDate, endDate)
# Compare ranges for booking overlaps
for booking in bookingsList:
booking_range = DateTimeRange(booking.startDate, booking.endDate)
if inserted_range.is_intersection(booking_range):
return Response(status=status.HTTP_400_BAD_REQUEST)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def test_normal(
self, start, start_format, end, end_format, separator, is_output_elapse, expected
):
dtr = DateTimeRange(start, end, start_format, end_format)
dtr.separator = separator
dtr.is_output_elapse = is_output_elapse
assert str(dtr) == expected
class TestDateTimeRange_validate_time_inversion:
@pytest.mark.parametrize(
["value"],
[
[DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME)],
[DateTimeRange(TEST_START_DATETIME, TEST_START_DATETIME)],
],
)
def test_normal(self, value):
value.validate_time_inversion()
def test_inversion(self, datetimerange_inversion):
with pytest.raises(ValueError):
datetimerange_inversion.validate_time_inversion()
@pytest.mark.parametrize(
["value"],
[
[DateTimeRange(None, None)],
[DateTimeRange(None, TEST_END_DATETIME)],
[DateTimeRange(TEST_START_DATETIME, None)],
],
)
def test_exception(self, value):
with pytest.raises(TypeError):
value.validate_time_inversion()
def update_training_for_staff_after_absence(sender, instance, **kwargs):
if instance.abs_type.abbr == "FOR":
absence_range = instance.datetime_range
old_absence_start_date = instance.tracker.previous("start_date")
old_absence_end_date = instance.tracker.previous("end_date")
old_absence_range = DateTimeRange(old_absence_start_date,
old_absence_end_date)
years = []
rt = RightTraining.objects.first()
if rt:
for value in absence_range.range(datetime.timedelta(days=1)):
if value.month in range(rt.start_month, 13):
year = value.year
else:
year = value.year - 1
if year not in years:
years.append(year)
if old_absence_start_date and old_absence_end_date:
for value in old_absence_range.range(
datetime.timedelta(days=1)):
if value.month in range(rt.start_month, 13):
year = value.year
else:
year = value.year - 1
if year not in years:
years.append(year)
call_command('update_training',
years=years,
staffs=[instance.staff.id])
def generate_timestamp(start_datetime, sampling_rate, signal_length):
"""
Parameters
----------
start_datetime :
sampling_rate : float
signal_length : int
Returns
-------
list : list of timestamps with length equal to signal_length.
"""
number_of_seconds = (signal_length - 1)/sampling_rate
if start_datetime is None:
start_datetime = dt.datetime.now()
end_datetime = start_datetime + dt.timedelta(seconds=number_of_seconds)
time_range = DateTimeRange(start_datetime, end_datetime)
timestamps = []
for value in time_range.range(dt.timedelta(seconds=1/sampling_rate)):
timestamps.append(value)
if len(timestamps) != signal_length:
raise Exception("Timestamp series generated is not valid, please "
"check sampling rate.")
return timestamps
def test_exception(self, start, start_format, end, end_format, separator,
is_output_elapse, expected):
dtr = DateTimeRange(start, end, start_format, end_format)
dtr.separator = separator
dtr.is_output_elapse = is_output_elapse
with pytest.raises(expected):
str(dtr)
def datetimerange_inversion():
value = DateTimeRange(
TEST_END_DATETIME, TEST_START_DATETIME)
value.start_time_format = ISO_TIME_FORMAT
value.end_time_format = ISO_TIME_FORMAT
return value
def test_get_records_wrong_range():
start_datetime = datetime.datetime(year=2020, month=1, day=1)
schedule = Schedule(start_datetime, duration=3600)
range_1 = DateTimeRange(start_datetime,
start_datetime + datetime.timedelta(minutes=1))
schedule.add_record('TYPE_1', range_1)
range_2 = DateTimeRange(start_datetime + datetime.timedelta(minutes=1),
start_datetime + datetime.timedelta(minutes=2))
schedule.add_record('TYPE_1', range_2)
assert len(schedule.records) == 2
required_range = DateTimeRange(
start_datetime + datetime.timedelta(minutes=3),
start_datetime + datetime.timedelta(minutes=4))
records = schedule.get_records_in_range(required_range)
assert len(records) == 0
required_range = DateTimeRange(
start_datetime + datetime.timedelta(minutes=2),
start_datetime + datetime.timedelta(minutes=3))
records = schedule.get_records_in_range(required_range)
assert len(records) == 0
def test_exception(
self, start, start_format, end, end_format,
separator, is_output_elapse, expected):
dtr = DateTimeRange(start, end, start_format, end_format)
dtr.separator = separator
dtr.is_output_elapse = is_output_elapse
with pytest.raises(expected):
str(dtr)
def test_reservation_may_be_requested_right_after_previous_one(resource):
resource.reserve(
DateTimeRange('2020-03-01 10:00:00', '2020-03-01 12:00:00'))
resource.reserve(
DateTimeRange('2020-03-01 12:00:00', '2020-03-01 14:00:00'))
assert len(resource.get_reserved_periods()) == 2
def test_normal(self):
value = DateTimeRange("2015-03-22T10:10:00+0900",
"2015-03-22T10:20:00+0900")
expected = DateTimeRange("2015-03-22T10:00:00+0900",
"2015-03-22T10:10:00+0900")
value -= timedelta(seconds=10 * 60)
assert value == expected
def beli_kamar(id_kamar):
if islogin():
status = True
d_checkin = request.form['checkin']
d_checkout = request.form['checkout']
d_kamar = kamar.get(kamar.id == id_kamar)
d_nama = request.form['nama']
d_ktp = request.form['ktp']
d_checkin = datetime.datetime.strptime(d_checkin, '%Y-%m-%d')
d_checkout = datetime.datetime.strptime(d_checkout, '%Y-%m-%d')
# cek
d_transaksi = transaksi.select().where(
(transaksi.selesai == False) & (transaksi.id_kamar == id_kamar))
if d_transaksi.exists():
for data in d_transaksi:
d_checkin_d = datetime.datetime(data.checkin.year,
data.checkin.month,
data.checkin.day, 0, 0)
d_checkout_d = datetime.datetime(data.checkout.year,
data.checkout.month,
data.checkout.day, 0, 0)
checkin_now = datetime.datetime(d_checkin.year,
d_checkin.month, d_checkin.day,
0, 0)
checkout_now = datetime.datetime(d_checkout.year,
d_checkout.month,
d_checkout.day, 0, 0)
time_range = DateTimeRange(checkin_now, checkout_now)
for date in time_range.range(datetime.timedelta(days=1)):
check = date
if d_checkin_d == check or d_checkout_d == check:
status = False
if status == True:
lama_menginap = datetime.datetime(
d_checkout.year, d_checkout.month,
d_checkout.day, 0, 0) - datetime.datetime(
d_checkin.year, d_checkin.month, d_checkin.day, 0, 0)
d_total_harga = int(lama_menginap.days) * int(d_kamar.harga)
transaksi.create(id_user=session['iduser'],
id_kamar=id_kamar,
nama_pemesan=d_nama,
no_ktp=d_ktp,
checkin=d_checkin,
checkout=d_checkout,
total_harga=d_total_harga,
waktu_transaksi=datetimenow())
return redirect(url_for('index'))
return redirect(url_for('index'))
return redirect(url_for('index'))
def test_reservation_cant_overlap_with_previous_ones(resource):
# given
resource.reserve(
DateTimeRange('2020-03-01 10:00:00', '2020-03-01 12:00:00'))
# when
result = resource.reserve(
DateTimeRange('2020-03-01 10:00:00', '2020-03-01 12:00:00'))
assert not result.is_success()
class TestDateTimeRange_split:
@pytest.mark.parametrize(
["dtr", "separator", "expected"],
[
[
DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME),
"2015-03-22 10:05:00" + TIMEZONE,
[
DateTimeRange(TEST_START_DATETIME,
"2015-03-22 10:05:00" + TIMEZONE),
DateTimeRange("2015-03-22 10:05:00" + TIMEZONE,
TEST_END_DATETIME),
],
],
[
DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME),
"2015-03-22 09:59:59" + TIMEZONE,
[DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME)],
],
[
DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME),
TEST_START_DATETIME,
[DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME)],
],
[
DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME),
END_DATETIME_TEXT,
[DateTimeRange(TEST_START_DATETIME, TEST_END_DATETIME)],
],
],
)
def test_normal(self, dtr, separator, expected):
assert dtr.split(separator) == expected
def add_appointment():
date = request.json['date']
time_from = request.json['time_from']
time_to = request.json['time_to']
if date == '' or time_from == '' or time_to == '':
return jsonify(message='date and time cannot be blank'),406
date_time_from = datetime.datetime.strptime(f'{date}-{time_from}','%Y-%m-%d-%H:%M')
date_time_to = datetime.datetime.strptime(f'{date}-{time_to}','%Y-%m-%d-%H:%M')
recieved_dates = DateTimeRange(f'{date}T{time_from}', f'{date}T{time_to}')
## any booking for the past dates or time cannot be accomodated.
if datetime.datetime.now() > date_time_from:
return jsonify(message='Any booking for the past dates or time cannot be accomodated'),406
if date_time_from > date_time_to:
return jsonify(message='Any booking for the past dates or time cannot be accomodated'), 406
## booking are'nt allowed during sunday
if datetime.datetime.strptime(date,'%Y-%m-%d').weekday() == 6:
return jsonify(message='Sorry appointments are only allowed from Monday to Saturday'),406
## bookings only allowed during opening-hourse
opening_hours = DateTimeRange(f'{date}T09:00', f'{date}T17:00')
if (recieved_dates in opening_hours) == False:
return jsonify(message='Appointments are only allowed from 9:00AM - 5:00PM'),406
## check for conflicting booking records
success_message = 'You added a new record!'
datas = Appointment.query.all()
if datas:
for data in datas:
data_dates = DateTimeRange(str(data.date_time_from).replace(' ','T'),str(data.date_time_to).replace(' ','T'))
if data_dates.is_intersection(recieved_dates):
return jsonify(message='There is a conflict between your schedule'),409
## adding records to the database
first_name = request.json['first_name']
last_name = request.json['last_name']
comments = request.json['comments']
print(first_name, last_name, comments)
new_appointment = Appointment(
first_name=first_name,
last_name=last_name,
comments=comments,
date_time_from=date_time_from,
date_time_to=date_time_to
)
db.session.add(new_appointment)
db.session.commit()
return jsonify(message=success_message),201
def saveDateRange(start, end):
givenRange = DateTimeRange(start, end)
tables = ['Jobs', 'ReviewJobs']
for table in tables:
data = []
query = 'SELECT * FROM ' + table
cur.execute(query)
results = [list(each) for each in cur.fetchall()]
for job in results:
dateRange = job[15]
d = [each.lstrip().rstrip() for each in dateRange.split("-")]
s = d[0].split("/")
startFormat = str(int(s[2]) + 2000) + "/" + s[1] + "/" + s[0]
inRange = False
if len(d) > 1:
e = d[1].split("/")
endFormat = str(int(e[2]) + 2000) + "/" + e[1] + "/" + e[0]
tableRange = DateTimeRange(startFormat, endFormat)
for day in tableRange.range(relativedelta(days=1)):
if day in givenRange:
inRange = True
else:
inRange = startFormat in givenRange
if inRange:
data.append(job)
columnNames = names.get(table)
file = "Date Range for " + table + " from " + start.replace("/", "-") + " to " + end.replace("/", "-") + ".csv"
if len(data) > 0:
data.insert(0, columnNames)
data.insert(1, [])
for i in range(len(data)):
line = data[i]
if (i == 0):
open(file, 'w+').close()
with open(file, 'a', newline='') as fp:
a = csv.writer(fp, delimiter=',')
line = [line]
a.writerows(line)
def test_normal(self, value, timezone, expected):
dtr = DateTimeRange(TEST_END_DATETIME, TEST_END_DATETIME)
dtr.set_start_datetime(value, timezone=timezone)
assert dtr.start_datetime == expected
def datetimerange_null():
value = DateTimeRange(None, None)
value.time_format = None
value.end_time_format = None
return value
def datetimerange_null_start():
value = DateTimeRange(None, TEST_END_DATETIME)
value.time_format = None
value.end_time_format = ISO_TIME_FORMAT
return value
def test_exception(self, start, end, expected):
dtr = DateTimeRange()
with pytest.raises(expected):
dtr.set_time_range(start, end)
def test_normal(self, start, end, expected):
dtr = DateTimeRange()
dtr.set_time_range(start, end)
assert dtr == expected
def test_normal(self, value, expected):
dtr = DateTimeRange(TEST_END_DATETIME, TEST_END_DATETIME)
dtr.set_end_datetime(value)
assert dtr.end_datetime == expected
