def post(self, request, *args, **kwargs): title = request.POST['title'] description = request.POST['description'] t = Ticket(title=title, description=description) t.save() data = serializers.serialize("json", [t]) return HttpResponse(data, mimetype='application/json')
def add_as_ticket(self, item): ticket = Ticket( title=item['title'], description=item['description'], price=item['price'], pickup_location=item['location'], seller_email_address=item['email'], seller_phone=item['phone'], external_src='craigslist', external_listing_url=item['link'] ) ticket.save()
def setUp(self): self.client = APIClient() # import first garage (209 Hitt St) from pickle dump with(open("api/tests/xgboost_tests_resources/garages.dat", "rb")) as file: garages = pickle.load(file) garage = garages[0] self.garage = Garage.objects.create(name=garage.name, start_enforce_time=garage.start_enforce_time, end_enforce_time=garage.end_enforce_time, enforced_on_weekends=garage.enforced_on_weekends, probability=garage.probability, latitude=garage.latitude, longitude=garage.longitude) existing_user_data = { "email": "*****@*****.**", "first_name": "Existing", "last_name": "User", "phone": "5735735733" } self.user = User.objects.create(**existing_user_data) self.user.set_password("defaultpassword") self.user.save() self.user_token = Token.objects.create(user=self.user) date_now = datetime.datetime.now() existing_park_data = { "start": date_now, "end": date_now + datetime.timedelta(hours=2), "ticket": Ticket(date=date_now + datetime.timedelta(hours=1)), "garage": self.garage, "user_id": self.user.pk } self.park = Park.objects.create(**existing_park_data) self.park.save()
def post(self, flight_id): """Tickets endpoint """ flight = Flight.get_or_404(flight_id) request_data = request.get_json() ticket_schema = TicketSchema() ticket_data = ticket_schema.load_object_into_schema(request_data) ticket_data["user_id"] = request.decoded_token["data"]["id"] ticket_data["flight_id"] = flight.id ticket = Ticket(**ticket_data) ticket.save() return { "status": "success", "message": SUCCESS_MSG["created"].format("Ticket"), "data": ticket_schema.dump(ticket).data }, 201
def setUp(self): # self.maxDiff = None self.client = APIClient() # import first (209 Hitt St) and second garage (AV1) from pickle dump with(open("api/tests/xgboost_tests_resources/garages.dat", "rb")) as file: garages = pickle.load(file) garage = garages[0] self.garage1 = Garage.objects.create(name=garage.name, start_enforce_time=garage.start_enforce_time, end_enforce_time=garage.end_enforce_time, enforced_on_weekends=garage.enforced_on_weekends, probability=garage.probability, latitude=garage.latitude, longitude=garage.longitude) garage = garages[1] self.garage2 = Garage.objects.create(name=garage.name, start_enforce_time=garage.start_enforce_time, end_enforce_time=garage.end_enforce_time, enforced_on_weekends=garage.enforced_on_weekends, probability=garage.probability, latitude=garage.latitude, longitude=garage.longitude) existing_user_data = { "email": "*****@*****.**", "first_name": "Existing", "last_name": "User", "phone": "5735735733" } self.user1 = User.objects.create(**existing_user_data) self.user1.set_password("defaultpassword") self.user1.save() self.user1_token = Token.objects.create(user=self.user1) existing_user2_data = { "email": "*****@*****.**", "first_name": "Existing2", "last_name": "User", "phone": "3753753755" } self.user2 = User.objects.create(**existing_user2_data) self.user2.set_password("defaultpassword") self.user2.save() self.user2_token = Token.objects.create(user=self.user2) date_now = datetime.datetime.now() existing_park_data = { "start": date_now, "garage": self.garage1, "user_id": self.user1.pk } self.park1 = Park.objects.create(**existing_park_data) self.park1.save() existing_park_data['start'] -= datetime.timedelta(hours=2) existing_park_data['garage'] = self.garage2 existing_park_data['end'] = existing_park_data['start'] + datetime.timedelta(hours=1) existing_park_data['ticket'] = Ticket(date=(existing_park_data['end'] - datetime.timedelta(minutes=30))) self.park2 = Park.objects.create(**existing_park_data)
def ticket(request): token = request.headers.get('token') token = Token.objects.filter(token=token) if token.exists(): user = token[0].user try: if request.method == 'POST': info = loads(request.body.decode('utf-8')) mess = info['message'] rate = info['rate'] t = Ticket(user=user, message=mess, rate=rate) t.save() return my_response(True, 'success', t.to_json()) elif request.method == 'GET': if token[0].is_admin: ticks = Ticket.objects.all() else: ticks = Ticket.objects.filter(user=user) _list = [] for t in ticks: _list.append(t.to_json()) return my_response(True, 'success', _list) else: return my_response(False, 'invalid method', {}) except Exception as e: return my_response(False, 'error in ticket, check body send, ' + str(e), {}) else: return my_response(False, 'token invalid', {})
def get(self, flight_id): """Tickets endpoint """ Flight.get_or_404(flight_id) tickets = Ticket.query_(request.args) ticket_schema = TicketSchema(many=True) return { "status": "success", "message": SUCCESS_MSG["fetched"].format("Tickets"), "data": ticket_schema.dump(tickets).data }, 200
def create_random_parks(n): # Test Data user to be used for creating test/mock data user = User.objects.get(first_name='Test Data') garages = Garage.objects.all() start_date = datetime.datetime(2020, 1, 1) # January 1, 2020 end_date = datetime.datetime.now() # The time right now, duh date_range = end_date - start_date for garage in garages: for i in range(0, n): # initialize random numbers random_start = random() random_end = random() random_ticket = random() random_ticket_compare = random() # determine start date (random date between 1/1/2020 and time right now) start = start_date + random_start * date_range # determine end date (random date between start date and 8 hours from then) interval_range = start - (start + datetime.timedelta(hours=8)) end = start + random_end * interval_range # default value for ticket (no ticket) ticket = None # determine whether to create random ticket if random_ticket >= random_ticket_compare: # determine ticket date (random date between start and end) park_range = end - start ticket_date = start + random_ticket * park_range # create ticket object ticket = Ticket(date=ticket_date) # create park object create_park(start=start, end=end, ticket=ticket, garage=garage, user=user)
def create_parks_updated(park_percent_thresh, park_ticket_percent_thresh, park_max_time, park_min_time, parks_per_iteration): # all parks will be added under the test user user = User.objects.get(first_name='Test Data') garages = Garage.objects.all() # for now, enforcement will be done in three routes / clusters num_routes = 3 routes = [] # load in the routes from the output route files of route_finder.py command for i in range(num_routes): routes.append( load_routes( "route_visualization/CondensedRoutes/condensed_route_g" + str((i + 1)) + ".json")) # today, set to 7:00 (begin patrol time) date = datetime.datetime.now() date = date.replace(hour=7, minute=0, second=0, microsecond=0) # get the list of times that each lot is patrolled patrol_times = [] for route in routes: patrol_times.append( get_patrol_times_list( patrol_time_start=date, patrol_time_end=(date + datetime.timedelta(minutes=660)), patrol_lot_time_min=5, patrol_lot_time_max=15, patrol_route=route)) # add previous 15 days to the queue for ticket generation dates = [] for i in range(1, 15): dates.append(date - datetime.timedelta(days=i)) # iterate over the past 15 days for date in dates: # random start time within 0-45 minutes of 7:00 am date_begin = date + datetime.timedelta(minutes=randrange(0, 45, 1)) # iterate over each 5 minute time interval in the enforcement hours (7:00am - 6:00pm) for current_time_offset in range(0, 660, 5): # how many parks pre time interval will be attempted in each garage for i in range(parks_per_iteration): # set the start time of the park park_start_time = date_begin + datetime.timedelta( minutes=current_time_offset) # set the length of the park park_length = randrange(park_min_time, park_max_time, 1) # set when the park will end park_end_time = park_start_time + datetime.timedelta( minutes=park_length) # iterate over all garages for garage in garages: # decide wether or not to generate a park park_prob = random() * 100 if (park_prob > park_percent_thresh): park_made = False # only give out tickets on weekdays if date.weekday() < 5: # for each route's patrol times for patrol_time in patrol_times: # for each lot's patrol time for lot_visited in patrol_time: # if the lot matches the garage name if lot_visited[ 0] == garage.name and park_made == False: # if the park range overlaps the ticketing range, give a ticket lot_visited_time1 = lot_visited[ 1].replace( year=park_start_time.year, month=park_start_time.month, day=park_start_time.day) lot_visited_time2 = lot_visited[ 2].replace( year=park_start_time.year, month=park_start_time.month, day=park_start_time.day) if park_start_time < lot_visited_time1 and park_end_time > lot_visited_time1: # make sure that the ticket_prob is under the ticketing threshold ticket_prob = random() * 100 if (ticket_prob < park_ticket_percent_thresh ): create_park( start=park_start_time, end=park_end_time, ticket=Ticket( date=random_date( lot_visited_time1, park_end_time)), garage=garage, user=user) park_made = True elif lot_visited_time1 < park_start_time and lot_visited_time2 > park_start_time: ticket_prob = random() * 100 if (ticket_prob < park_ticket_percent_thresh ): create_park( start=park_start_time, end=park_end_time, ticket=Ticket( date=random_date( park_start_time, lot_visited_time2) ), garage=garage, user=user) park_made = True if park_made == False: # test it again for the threshold, too many parks being created park_prob = random() * 100 if (park_prob > park_percent_thresh): create_park(start=park_start_time, end=park_end_time, ticket=None, garage=garage, user=user) park_made = False
def create_structured_parks_for_day(day_start): user = User.objects.get(first_name='Test Data') garages = Garage.objects.all() # uses the route finder data to try and "intelligently" use possible routes the parking # attendents could take # for now, three routes / clusters num_routes = 3 routes = [] # load in the routes from the output route files of route_finder.py command for i in range(num_routes): routes.append( load_routes( "route_visualization/CondensedRoutes/condensed_route_g" + str((i + 1)) + ".json")) # shuffle routes every weekday for route in routes: weekno = datetime.datetime.today().weekday() length = len(route) - 1 if weekno < 5: for i in range(weekno): route.insert(0, route.pop()) # constant, just a guess of how long it takes them to patrol a lot time_to_ticket_lot = (math.floor(random() * 100) % 7) + 15 # random amount of tickets they give at each lot num_tickets = (math.floor(random() * 100) % 15) + 2 # the current time of the patrol current_patrol_dt = None # time they leave each lot leaveTime = [] # iterate over each route for route in routes: # start at 8:00am current_patrol_dt = day_start # iterate over each place in the route, IN ORDER for place in route: # update the time they visit the lot, add on the time it takes to get between lots current_patrol_dt = current_patrol_dt + datetime.timedelta( seconds=(math.floor(place[1]))) # give out tickets at each lot for i in range(num_tickets): # get the park dates/times based on the current time dates = generate_start_end_ticket_dates(current_patrol_dt) # find the garage object that relates to the current place being enforced in the route garageParked = None for garage in garages: if (place[0] == garage.name): garageParked = garage # only give tickets out on the weekdays weekno = datetime.datetime.today().weekday() if weekno < 5: # create the park in the DB, with ticket create_park(start=dates[0], end=dates[1], ticket=Ticket(date=dates[2]), garage=garageParked, user=user) else: # create the park in the DB, no ticket create_park(start=dates[0], end=dates[1], ticket=None, garage=garageParked, user=user) # update the current time with the time it takes to ticket a lot current_patrol_dt = current_patrol_dt + datetime.timedelta( minutes=time_to_ticket_lot) # update random time to ticket each lot time_to_ticket_lot = (math.floor(random() * 100) % 7) + 15 # updated the random number of tickets to give at each lot num_tickets = (math.floor(random() * 100) % 15) + 2 # get the time they leave the last place in the route for each route, # they will restart the route at this time in the next step leaveTime.append(current_patrol_dt) indx = 0 # for now, I run the routes a second time, # becuase it ended up finishing each route about halfway through the day for route in routes: current_patrol_dt = leaveTime[indx] for place in route: current_patrol_dt = current_patrol_dt + datetime.timedelta( seconds=(math.floor(place[1]))) if current_patrol_dt.hour >= 18: return for i in range(num_tickets): dates = generate_start_end_ticket_dates(current_patrol_dt) garageParked = None for garage in garages: if (place[0] == garage.name): garageParked = garage weekno = datetime.datetime.today().weekday() if weekno < 5: create_park(start=dates[0], end=dates[1], ticket=Ticket(date=dates[2]), garage=garageParked, user=user) else: create_park(start=dates[0], end=dates[1], ticket=None, garage=garageParked, user=user) current_patrol_dt = current_patrol_dt + datetime.timedelta( minutes=time_to_ticket_lot) time_to_ticket_lot = (math.floor(random() * 100) % 7) + 15 num_tickets = (math.floor(random() * 100) % 15) + 2 indx = indx + 1
def new_ticket(app): """new Ticket """ return Ticket(**ticket_data[0])
session.commit() # TICKETS tickets = [] classes = [c for c in Classes] MIN_PRICE = 5 MAX_PRICE = 200 for ticket_id in range(NUM_TICKETS): price = round( float(randint(MIN_PRICE, MAX_PRICE)) + randint(0, 1) * random(), 2, ) tickets.append( Ticket( id=ticket_id, created_at=now + timedelta(seconds=randint(-TEN_DAYS, -HOUR)), user_id=choice(range(len(users) - 1)), # last user has no tickets train_id=choice(range(len(trains) - 1)), # last train has no tickets price=price, car_class=choice(classes), )) session.bulk_save_objects(tickets) session.commit() print("done")
def get_ticket_testing(self, ticket_id): return Ticket.get_or_404(ticket_id)
def obtainTicketList(self, ipAddress): try: tickets = Ticket.objects.all() auditoriums = Auditorium.objects.all() events = Event.objects.all() url = 'https://' + ipAddress + '/api/tickets/' print('GET: ' + url) response = requests.get(url, headers=self.headers, timeout=2, verify=False) f = open('log/GET_TICKET_LIST_INTERNAL.log', 'w') f.write('GET: ' + url + '\nResponse\n') f.write(response.text) f.close() tickets_dict = response.json() audi_do_not_exist = True event_do_not_exist = True if tickets_dict and 'NotReady' not in tickets_dict: for ticket_dict in tickets_dict: tickets = Ticket.objects.all() auditoriums = Auditorium.objects.all() events = Event.objects.all() ticketHash = ticket_dict.get('ticketHash') owner = ticket_dict.get('owner') ticket_status = ticket_dict.get('status') validationTime = ticket_dict.get('validationTime') event_dict = ticket_dict.get('event') event_name = event_dict.get('name') event_time = event_dict.get('time') auditorium_dict = event_dict.get('auditorium') auditorium_name = auditorium_dict.get('name') auditorium_address = auditorium_dict.get('address') auditorium = Auditorium(name=auditorium_name, address=auditorium_address) for audi_in_db in auditoriums: if audi_in_db.name == auditorium_name and audi_in_db.address == auditorium_address: audi_do_not_exist = False auditorium = audi_in_db break if audi_do_not_exist: auditorium.save() event = Event(name=event_name, time=event_time, auditorium=auditorium) for event_in_db in events: if event_in_db.name == event_name: event_do_not_exist = False event = event_in_db break if event_do_not_exist: event.save() ticket = Ticket(ticketHash=ticketHash, status=ticket_status, validationTime=validationTime, owner=owner, event=event) for tick in tickets: if tick.ticketHash == ticketHash: ticket = tick ticket.save() else: print('Received: No event found retry in 1 sec') time.sleep(1) except requests.exceptions.Timeout: print('TIMEOUT INTERNAL OBTAIN TICKET LIST')
def obtainTicketsFromGestionWebsite(self, ip): url = self.heroku_url + 'tickets/' headers = self.headers headers['ipAddress'] = ip try: tickets = Ticket.objects.all() auditoriums = Auditorium.objects.all() events = Event.objects.all() print('GET: ' + url) response = requests.get(url, headers=self.headers, timeout=10) f = open('log/GET_TICKET_LIST_GESTION.log', 'w') f.write('GET: ' + url + ' | Headers: ' + str(headers) + '\nResponse\n') f.write(response.text) f.close() tickets_dict = response.json() audi_do_not_exist = True event_do_not_exist = True if not isinstance(tickets_dict, str): for ticket_dict in tickets_dict: tickets = Ticket.objects.all() auditoriums = Auditorium.objects.all() events = Event.objects.all() ticketHash = ticket_dict.get('id') owner = ticket_dict.get('owner') ticket_status = 'Non-Validated' event_dict = ticket_dict.get('event') event_name = event_dict.get('name') event_time = event_dict.get('startDate') auditorium_dict = event_dict.get('auditorium') auditorium_name = auditorium_dict.get('name') auditorium_address = auditorium_dict.get('address') auditorium = Auditorium(name=auditorium_name, address=auditorium_address) for audi_in_db in auditoriums: if audi_in_db.name == auditorium_name and audi_in_db.address == auditorium_address: audi_do_not_exist = False auditorium = audi_in_db break if audi_do_not_exist: auditorium.save() event = Event(name=event_name, time=event_time, auditorium=auditorium) for event_in_db in events: if event_in_db.name == event_name: event_do_not_exist = False event = event_in_db break if event_do_not_exist: event.save() ticket = Ticket(ticketHash=ticketHash, status=ticket_status, owner=owner, event=event) for tick in tickets: if tick.ticketHash == ticketHash: ticket = tick ticket.save() else: print('Received: No event found retry in 1 sec') time.sleep(1) except requests.exceptions.Timeout: print('TIMEOUT OBTAIN TICKET LIST') except ValueError: print('INVALID JSON FORMAT') print(response.text)