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