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 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)
