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 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 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 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
def create_troubleshooting_in_daily_follow_up(sender, instance, **kwargs):
today = instance.presence.date
classroom = instance.presence.classroom
# get general periods for this weekday and this classroom
periods = list(
Period.objects.filter(weekday=today.isoweekday()).order_by("order"))
# get timerange now
if not instance.presence.departure_time:
time_range = DateTimeRange(
datetime.datetime.combine(today, instance.presence.arrival_time),
datetime.datetime.combine(today, instance.presence.arrival_time))
else:
time_range = DateTimeRange(
datetime.datetime.combine(today, instance.presence.arrival_time),
datetime.datetime.combine(today, instance.presence.departure_time))
periods_in_range = []
# get period interaction from arrival_time
for period in periods:
period_range = DateTimeRange(
datetime.datetime.combine(today, period.start_time),
datetime.datetime.combine(today, period.end_time))
if time_range.is_intersection(period_range):
try:
ChildToPeriod.objects.get(
child=instance.presence.child,
child__status=Child.STATUS.in_progress,
start_date__lte=today,
end_date__gte=today,
period=period,
child__classroom=classroom)
except ChildToPeriod.DoesNotExist:
periods_in_range.append(period.id)
if periods_in_range:
ts, created = Troubleshooting.objects.get_or_create(
daily_follow_up=instance)
ts.periods.set(periods_in_range)
else:
try:
ts = Troubleshooting.objects.get(daily_follow_up=instance)
except Troubleshooting.DoesNotExist:
pass
else:
ts.delete()
# sinon trouble
# on check les early troubleshooting
try:
early_troubleshooting = EarlyTroubleshooting.objects.get(
date=today, child=instance.presence.child)
except EarlyTroubleshooting.DoesNotExist:
pass
else:
ts, created = Troubleshooting.objects.get_or_create(
daily_follow_up=instance)
period_list = list(early_troubleshooting.periods.all())
ts.periods.set(period_list)
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 handle_page(response, ul, lr, start, end):
return_items = []
for items in response['mosaics']:
bd = items['bbox']
mosgeom = shape(Polygon(box(bd[0], bd[1], bd[2], bd[3]).exterior.coords))
boundgeom = shape(Polygon(box(ul[0], lr[1], lr[0], ul[1])))
proj = partial(pyproj.transform, pyproj.Proj(init='epsg:4326'), pyproj.Proj(init='epsg:3857'))
boundgeom = transform(proj, boundgeom)
mosgeom = transform(proj, mosgeom)
if boundgeom.intersection(mosgeom).is_empty:
pass
else:
id = items['id']
quad_ids = []
r = requests.get('https://api.planet.com/basemaps/v1/mosaics/' + str(id) + '/quads?bbox=' +
str(ul[0])+'%2C'+str(lr[1])+'%2C'+str(lr[0])+'%2C'+str(ul[1]) +
'&api_key=' + api_key)
resp = r.json()
if len(resp['items']) > 0:
time_range = DateTimeRange(items['first_acquired'].split('T')[0],
items['last_acquired'].split('T')[0])
x = DateTimeRange(start, end)
if time_range.is_intersection(x) is True:
quad_ids += [it['id'] for it in resp['items']]
while resp['_links'].get('_next') is not None:
r = requests.get(resp['_links'].get('_next'))
resp = r.json()
time_range = DateTimeRange(items['first_acquired'].split('T')[0],
items['last_acquired'].split('T')[0])
x = DateTimeRange(start, end)
if time_range.is_intersection(x) is True:
quad_ids += [it['id'] for it in resp['items']]
if len(quad_ids) > 0:
return_items += [{"name": str(items['name']),
"mosaic_id": str(items['id']),
"quad_ids": tuple(set(quad_ids)),
"first_acquired": str(items['first_acquired']).split('T')[0],
"last_acquired": str(items['last_acquired']).split('T')[0],
"coordinate_system": int(items['coordinate_system'].split(':')[1]),
"resolution": format(float(str(items['grid']['resolution'])),'.3f')}]
return return_items
def handle_page(response, gmainbound, start, end, outfile):
for items in response['mosaics']:
bd = items['bbox']
mosgeom = shape(
Polygon(box(bd[0], bd[1], bd[2], bd[3]).exterior.coords))
gboundlist = gmainbound.split(',')
boundgeom = shape(
Polygon(
box(float(gboundlist[0]), float(gboundlist[1]),
float(gboundlist[2]), float(gboundlist[3]))))
proj = partial(pyproj.transform, pyproj.Proj(init='epsg:4326'),
pyproj.Proj(init='epsg:3857'))
boundgeom = transform(proj, boundgeom)
mosgeom = transform(proj, mosgeom)
if boundgeom.intersection(mosgeom).is_empty:
pass
else:
id = items['id']
r = requests.get(
'https://api.planet.com/mosaic/experimental/mosaics/' +
str(id) + '/quads?bbox=' + str(gboundlist[0]) + '%2C' +
gboundlist[1] + '%2C' + gboundlist[2] + '%2C' + gboundlist[3],
auth=(PL_API_KEY, ''))
resp = r.json()
if len(resp['items']) > 0:
time_range = DateTimeRange(
items['first_acquired'].split('T')[0],
items['last_acquired'].split('T')[0])
x = DateTimeRange(start, end)
if time_range.is_intersection(x) is True:
#print(boundgeom.intersection(mosgeom).area/1000000)
print('Mosaic name: ' + str(items['name']))
print('Mosaic Resolution: ' +
str(items['grid']['resolution']))
print('Mosaic ID: ' + str(items['id']))
name = str(items['name'])
ids = str(items['id'])
facq = str(items['first_acquired']).split('T')[0]
lacq = str(items['last_acquired']).split('T')[0]
res = str(items['grid']['resolution'])
print('')
with open(outfile, 'a') as csvfile:
writer = csv.writer(csvfile,
delimiter=',',
lineterminator='\n')
writer.writerow(
[name, ids, facq, lacq,
format(float(res), '.3f')])
csvfile.close()
def get_records_in_range(self, required_range: DateTimeRange):
"""
Return records, which are:
1) located in required_range
2) intersected by required_range
:param required_range:
:return: List of records
"""
if not self.records:
return []
result = []
for record in self.records:
rec_range = record['range']
if required_range.is_intersection(rec_range) and \
required_range.end_datetime != rec_range.start_datetime and \
required_range.start_datetime != rec_range.end_datetime:
result.append(record)
return result
def clean(self):
"""
Custom validation of fields
Ex.: dt_start must be lower than a dt_end
:return:
"""
cleaned_data = super().clean()
dt_start = cleaned_data.get('dt_start')
dt_end = cleaned_data.get('dt_end')
if dt_start >= dt_end:
self.start_end_excetion(
msg='The start date and time of the reservation\
must be less than the end date and time.'
)
return
elif dt_start < datetime.now(tz=timezone(TIME_ZONE)):
self.start_end_excetion(
msg='The start time cannot be less than the current time.')
return
elif dt_end - dt_start > timedelta(hours=MAX_BOOKING_DURATION):
self.start_end_excetion(
msg=
f'You can\'t book for more than {MAX_BOOKING_DURATION} hours')
return
booking_datetime_range = DateTimeRange(dt_start, dt_end)
reservations = TableBookingQueue.objects.filter(
table=cleaned_data.get('table'))
for busy_table in reservations:
busy_table_datetime_range = DateTimeRange(busy_table.dt_start,
busy_table.dt_end)
if booking_datetime_range.is_intersection(
busy_table_datetime_range):
self.start_end_excetion(msg='This range is already booked :3')
break
def validate_reprocessing_schedules_overlaps(
self, all_scopes_to_reprocess, end_reprocess_time,
start_reprocess_time):
scheduling_range = DateTimeRange(
start_reprocess_time, end_reprocess_time)
for scope_to_reprocess in all_scopes_to_reprocess:
all_reprocessing_schedules = self.schedule_reprocessing_db.get_all(
identifier=[scope_to_reprocess.identifier])
LOG.debug("All schedules [%s] for reprocessing found for scope "
"[%s]", all_reprocessing_schedules, scope_to_reprocess)
if not all_reprocessing_schedules:
LOG.debug(
"No need to validate possible collision of reprocessing "
"for scope [%s] because it does not have active "
"reprocessing schedules." % scope_to_reprocess)
continue
for schedule in all_reprocessing_schedules:
scheduled_range = DateTimeRange(
tzutils.local_to_utc(schedule.start_reprocess_time),
tzutils.local_to_utc(schedule.end_reprocess_time))
try:
if scheduling_range.is_intersection(scheduled_range):
raise http_exceptions.BadRequest(
self.generate_overlap_error_message(
scheduled_range, scheduling_range,
scope_to_reprocess))
except ValueError as e:
raise http_exceptions.BadRequest(
self.generate_overlap_error_message(
scheduled_range, scheduling_range,
scope_to_reprocess) + "Error: [%s]." % e)
def intersect_arcs(df_rs: pd.DataFrame,
logger: logging.Logger) -> Tuple[int, pd.DataFrame]:
"""
intersect_arcs determines which observation intervals belong to which TLE interval
"""
cFuncName = colored(os.path.basename(__file__),
'yellow') + ' - ' + colored(
sys._getframe().f_code.co_name, 'green')
# number of arcs according to observations
nr_arcs_obs = []
for prn in df_rs.index:
# find maximum number of arcs in observations
nr_arcs_obs.append(longest(df_rs.loc[prn]['obs_arc_count']))
logger.info(
'{func:s}: number of observed arcs per prn: {arcs!s}'.format(
arcs=nr_arcs_obs, func=cFuncName))
# find number of ars per PRN from TLE
nr_arcs_tle = []
for prn in df_rs.index:
# find maximum number of arcs in observations
nr_arcs_tle.append(longest(df_rs.loc[prn]['tle_arc_count']))
nr_arcs = max(nr_arcs_tle)
logger.info(
'{func:s}: number of predicted arcs per prn: {arcs!s}'.format(
arcs=nr_arcs_tle, func=cFuncName))
# make the arcs fit together by comparing the start / end dates between observed and TLEs
df_rs['intersect'] = pd.Series(dtype=object)
J2000 = datetime(2000, 1, 1)
for i_prn, prn in enumerate(df_rs.index):
logger.info('{func:s}: PRN {prn:s}'.format(prn=prn, func=cFuncName))
prn_intersect = [np.nan] * nr_arcs_obs[i_prn]
for i_tle, (tle_rise, tle_set) in enumerate(
zip(df_rs.loc[prn]['tle_rise'], df_rs.loc[prn]['tle_set'])):
tle_range = DateTimeRange(datetime.combine(J2000, tle_rise),
datetime.combine(J2000, tle_set))
tle_range.start_time_format = '%H:%M:%S'
tle_range.end_time_format = '%H:%M:%S'
logger.info('{func:s}: tle_range = {tler!s}'.format(
tler=tle_range, func=cFuncName))
for i_obs, (obs_start, obs_end) in enumerate(
zip(df_rs.loc[prn]['obs_rise'],
df_rs.loc[prn]['obs_set'])):
obs_range = DateTimeRange(datetime.combine(J2000, obs_start),
datetime.combine(J2000, obs_end))
obs_range.start_time_format = '%H:%M:%S'
obs_range.end_time_format = '%H:%M:%S'
logger.info(
'{func:s}: obs_range = {obsr!s} intersect = {int!s}'
.format(obsr=obs_range,
int=tle_range.is_intersection(obs_range),
func=cFuncName))
if tle_range.is_intersection(obs_range):
prn_intersect[i_obs] = i_tle
# store in the itersection column
df_rs.loc[prn, 'intersect'] = prn_intersect
return nr_arcs, df_rs
def callNusmodApi(date, day, start_time, end_time, list_of_rooms,
list_of_all_rooms):
url = "https://api.nusmods.com/v2/2020-2021/semesters/1/venueInformation.json"
http = urllib3.PoolManager()
json_obj = http.request('GET', url)
text = json.loads(json_obj.data.decode('UTF-8'))
current_weekNo = roomSearch.return_weekNo(date)
unavailableRoom = []
for rooms in list_of_rooms:
for index in range(len(text[rooms])):
if text[rooms][index]["classes"]:
for class_index in range(len(text[rooms][index]["classes"])):
weekNo = text[rooms][index]["classes"][class_index][
"weeks"]
for num in weekNo:
if int(current_weekNo) == num:
if text[rooms][index]["classes"][class_index][
"day"] == day:
start_hour = (text[rooms][index]["classes"]
[class_index]["startTime"][0:2])
start_min = (text[rooms][index]["classes"]
[class_index]["startTime"][2:4])
end_hour = (text[rooms][index]["classes"]
[class_index]["endTime"][0:2])
end_min = (text[rooms][index]["classes"]
[class_index]["endTime"][2:4])
currentDate = datetime.datetime.now(
pytz.timezone('Asia/Singapore'))
lesson_start = datetime.datetime(
int(currentDate.strftime("%Y")),
int(currentDate.strftime("%m")),
int(currentDate.strftime("%d")),
int(start_hour), int(start_min), 0)
lesson_end = datetime.datetime(
int(currentDate.strftime("%Y")),
int(currentDate.strftime("%m")),
int(currentDate.strftime("%d")),
int(end_hour), int(end_min), 0)
lesson_range = DateTimeRange(
pytz.utc.localize(lesson_start),
pytz.utc.localize(lesson_end))
searchTime = DateTimeRange(
pytz.utc.localize(start_time),
pytz.utc.localize(end_time))
if lesson_range.is_intersection(searchTime):
unavailableRoom.append(rooms)
start_time_string = start_time.strftime("%H%M")
end_time_string = end_time.strftime("%H%M")
date_string = date.strftime("%Y-%m-%d")
values = (date_string, start_time_string, end_time_string)
cur.execute(
"SELECT DISTINCT room_no FROM studentsavers.rooms WHERE date=%s AND start_time=%s AND end_time=%s;",
values)
sqlresult = cur.fetchall()
unavailableRoom = list(dict.fromkeys(unavailableRoom))
for r in unavailableRoom:
list_of_rooms.remove(r)
for items in list_of_rooms:
list_of_all_rooms.append(items)
available_rooms = list_of_all_rooms
for checked_in_rooms in sqlresult:
checked_in_rooms = ''.join(''.join(map(str,
checked_in_rooms)).split('),'))
for avail_room in available_rooms:
if avail_room == checked_in_rooms:
available_rooms.remove(avail_room)
return available_rooms
