def test_with_valid_vehicle(self):
num_slots = self.service.create_parking_lot_of_size(2)
self.assertEqual(2, num_slots)
driver = Driver(22)
vehicle1 = Vehicle("pb08-11-22-random", driver)
parked_slot = self.service.park_vehicle(vehicle1)
self.assertEqual(parked_slot.number, 1)
self.assertEqual(parked_slot.parked_vehicle.number,
"pb08-11-22-random")
driver = Driver(23)
vehicle1clone = Vehicle("pb08-11-22-random", driver)
with self.assertRaises(DuplicateVehicleError):
parked_slot = self.service.park_vehicle(vehicle1clone)
driver = Driver(23)
vehicle2 = Vehicle("pb08-11-23-random", driver)
parked_slot = self.service.park_vehicle(vehicle2)
self.assertEqual(parked_slot.number, 2)
self.assertEqual(parked_slot.parked_vehicle.number,
"pb08-11-23-random")
driver = Driver(23)
vehicle4 = Vehicle("pb08-11-34-random", driver)
with self.assertRaises(ParkingFullError):
parked_slot = self.service.park_vehicle(vehicle4)
self.assertEqual(len(self.dao.empty_slots_heap), 0)
def test_valid_vehicle_parking(self):
self.assertTrue(self.dao.create_slots(3))
self.assertEqual(self.dao.capacity, 3)
self.assertEqual(len(self.dao.empty_slots_heap), 3)
self.assertEqual(len(self.dao.slot_number_to_slot), 3)
driver = Driver(22)
vehicle1 = Vehicle("pb08-11-22-random", driver)
parked_slot = self.dao.park_vehicle_at_closest_empty_slot(vehicle1)
self.assertEqual(len(self.dao.empty_slots_heap), 2)
self.assertEqual(parked_slot.number, 1)
driver = Driver(23)
vehicle1clone = Vehicle("pb08-11-22-random", driver)
with self.assertRaises(DuplicateVehicleError):
parked_slot = self.dao.park_vehicle_at_closest_empty_slot(
vehicle1clone)
self.assertEqual(len(self.dao.empty_slots_heap), 2)
driver = Driver(23)
vehicle2 = Vehicle("pb08-11-23-random", driver)
parked_slot = self.dao.park_vehicle_at_closest_empty_slot(vehicle2)
self.assertEqual(len(self.dao.empty_slots_heap), 1)
self.assertEqual(parked_slot.number, 2)
driver = Driver(23)
vehicle3 = Vehicle("pb08-11-33-random", driver)
parked_slot = self.dao.park_vehicle_at_closest_empty_slot(vehicle3)
self.assertEqual(len(self.dao.empty_slots_heap), 0)
self.assertEqual(parked_slot.number, 3)
driver = Driver(23)
vehicle4 = Vehicle("pb08-11-34-random", driver)
with self.assertRaises(ParkingFullError):
parked_slot = self.dao.park_vehicle_at_closest_empty_slot(vehicle4)
self.assertEqual(len(self.dao.empty_slots_heap), 0)
def test_with_invalid_driver(self):
self.assertTrue(self.dao.create_slots(3))
with self.assertRaises(InvalidDriverError):
driver = None
v = Vehicle("rndomplate", driver)
parked_slot = self.dao.park_vehicle_at_closest_empty_slot(v)
with self.assertRaises(InvalidDriverError):
driver = Driver(-23)
with self.assertRaises(InvalidDriverError):
driver = Driver(None)
v = Vehicle("rndomplate", driver)
parked_slot = self.dao.park_vehicle_at_closest_empty_slot(v)
def setUp(self):
self.dao = ParkingLotDao()
self.dao.create_slots(3)
d1 = Driver(18)
v1 = Vehicle("num1", d1)
self.dao.park_vehicle_at_closest_empty_slot(v1)
d2 = Driver(18)
v2 = Vehicle("num2", d2)
self.dao.park_vehicle_at_closest_empty_slot(v2)
d3 = Driver(20)
v3 = Vehicle("num3", d3)
self.dao.park_vehicle_at_closest_empty_slot(v3)
def register():
fullname = request.json.get('fullname')
email = request.json.get('email')
password = request.json.get('password')
if not email:
return jsonify({"msg": "Email is required"}), 422
if not fullname:
return jsonify({"msg": "Name is required"}), 422
if not password:
return jsonify({"msg": "Password is required"}), 422
driver = Driver.query.filter_by(email=email).first()
if driver:
return jsonify({"msg": "This email already register"}), 422
driver = Driver()
driver.email = email
driver.fullname = fullname
driver.password = bcrypt.generate_password_hash(password)
db.session.add(driver)
db.session.commit()
if bcrypt.check_password_hash(driver.password, password):
access_token = create_access_token(identity=driver.email)
data = {"access_token": access_token, "consumer": driver.serialize()}
return jsonify(data), 200
else:
return jsonify({"msg": "Email or password incorrect"}), 401
def post(self):
data = request.get_json()
newDriver = Driver(data['name'], data['price_base'],
data['price_per_mile'], data['tier'])
db.session.add(newDriver)
db.session.commit()
return newDriver.id
def post(self):
new_name = self.request.get("name")
new_employeeid = self.request.get("employeeid")
errors = {}
existing_driver = self.get_driver_by_name(new_name)
has_error = False
if not new_name:
errors['name_error'] = "Please enter a name."
has_error = True
elif (new_employeeid):
driver = Driver(name=new_name, employeeid=int(new_employeeid))
driver.put()
self.redirect('/drivers')
else:
has_error = True
if not new_employeeid:
errors['employeeid_error'] = "Please enter an Employee ID"
if has_error:
t = jinja_env.get_template("drivers.html")
response = t.render(name=new_name,
employeeid=new_employeeid,
errors=errors,
drivers=self.get_drivers())
self.response.out.write(response)
else:
t = jinja_env.get_template("drivers.html")
content = t.render(drivers=self.get_drivers())
self.redirect('/drivers')
def setUp(self):
self.dao = ParkingLotDao()
self.service = ParkingLotService(self.dao)
self.service.create_parking_lot_of_size(3)
d1 = Driver(18)
v1 = Vehicle("num1", d1)
self.service.park_vehicle(v1)
d2 = Driver(18)
v2 = Vehicle("num2", d2)
self.service.park_vehicle(v2)
d3 = Driver(20)
v3 = Vehicle("num3", d3)
self.service.park_vehicle(v3)
def test_get_existing_token(self):
d = Driver('get_existing_token_test')
db.session.add(d)
db.session.commit()
self.assertEqual(len(Driver.query.all()), 1)
a = get_user_from_token('get_existing_token_test')
self.assertEqual(a, d)
self.assertEqual(len(Driver.query.all()), 1)
def test_interface(self):
self.dao = MagicMock()
mockVehicle = Vehicle("mock", Driver(15))
self.dao.unpark_vehicle_at_slot_number = MagicMock(
return_value=mockVehicle)
self.service = ParkingLotService(self.dao)
output = self.service.empty_slot(3)
self.dao.unpark_vehicle_at_slot_number.assert_called_once_with(3)
self.assertEqual(output, mockVehicle)
def add_driver(name, version):
with db_session:
if select(d for d in Driver
if d.name == name and d.version == version).count() > 0:
raise Exception('Driver already exists')
driver = Driver(name=name, version=version)
return driver
def test_with_valid_vehicle(self):
driver = Driver(33)
vehicle = Vehicle("random", driver)
slot = ParkingSlot(1, vehicle)
self.dao.park_vehicle_at_closest_empty_slot = MagicMock(
return_value=slot)
res = self.service.park_vehicle(vehicle)
self.dao.park_vehicle_at_closest_empty_slot.assert_called_once_with(
vehicle)
self.assertEqual(res, slot)
def test_with_invalid_driver(self):
num_slots = self.service.create_parking_lot_of_size(2)
self.assertEqual(2, num_slots)
with self.assertRaises(InvalidDriverError):
driver = None
v = Vehicle("rndomplate", driver)
parked_slot = self.service.park_vehicle(v)
with self.assertRaises(InvalidDriverError):
driver = Driver(None)
v = Vehicle("rndomplate", driver)
parked_slot = self.service.park_vehicle(v)
def testDriverCreate(self):
test_token = "test_token"
# Create driver
d = Driver(test_token)
db.session.add(d)
db.session.commit()
# Test query
drivers = Driver.query.all()
self.assertEqual(len(drivers), 1)
self.assertEqual(drivers[0].token, test_token)
def create_env(task):
if task == 'lds':
return LDS()
elif task == 'driver':
return Driver()
elif task == 'tosser':
return Tosser()
elif task == 'fetch':
return Fetch()
else:
print('There is no task called ' + task)
exit(0)
def get_user_from_token(token):
try:
#TODO enable token authorization
#idinfo = verify_id_token(token, CLIENT_ID)
driver = Driver.query.filter_by(token=token).first()
if driver:
return driver
else:
driver = Driver(token)
db.session.add(driver)
db.session.commit()
return driver
except crypt.AppIdentityError:
return None
def auth_driver(user_id, login, password):
__init_firebase__()
snapshot = db.reference('drivers').get()
for driver in snapshot:
driver_credentials = snapshot[driver]
if driver_credentials['login'] == login and driver_credentials[
'password'] == password:
driver_reference = db.reference('drivers').child(driver)
# driver is online
driver_reference.update({
'active': 1,
})
return Driver(user_id, driver_credentials)
return None
def add_driver_to_fuel(fuel_version, name, version):
with db_session:
if select(d for d in Driver
if d.name == name and d.version == version).count() > 0:
raise Exception('Driver already exists')
fuel_version = get(fv for fv in FuelVersion if fv.name == fuel_version)
if fuel_version is None:
raise Exception('Unknown Fuel version')
driver = Driver(fuel_version=fuel_version, name=name, version=version)
return driver
def create_env(task):
if task == 'driver':
return Driver()
elif task == 'lunarlander':
return LunarLander()
elif task == 'mountaincar':
return MountainCar()
elif task == 'swimmer':
return Swimmer()
elif task == 'tosser':
return Tosser()
else:
print('There is no task called ' + task)
exit(0)
def drivers(request):
if request.method == 'GET':
data = serializers.serialize("json", Driver.objects.all())
return HttpResponse(data, content_type='application/json')
if request.method == 'POST':
req = json.loads(request.body)
for item in req:
name = item['driverName'].split(" ")
firstName = name[0]
lastName = name[1]
id = item['driverId']
startTime = item['driverStartTime']
endTime = item['driverEndTime']
time = item['driverBlockTime']
try:
Block.objects.get(startTime=startTime)
except:
block = Block(startTime=startTime, endTime=endTime, shiftLength=time)
block.save()
try:
Driver.objects.get(DPID=id)
except ObjectDoesNotExist:
block = Block.objects.get(startTime=startTime)
driver = Driver(DPID=id,
firstName = firstName,
lastName = lastName,
shiftLength = time,
startTime = startTime,
endTime = endTime,
block = block
)
driver.save()
return HttpResponse("Kevin is the greatest of all time --drivers")
def test_with_not_created_parking_slot(self):
with self.assertRaises(ParkingNotCreatedError):
driver = Driver(18)
v = Vehicle("rndomplate", driver)
parked_slot = self.dao.park_vehicle_at_closest_empty_slot(v)
def dump(file_name):
with open(file_name) as csv_file:
reader = csv.reader(csv_file, delimiter=',', quotechar='|')
vendors = set([
'Intel', 'Supermicro', 'Lenovo', 'Mellanox', 'HP', 'Dell',
'Ericsson'
])
default = Driver(name="default", version="1.0")
for i, row in enumerate(reader):
if i > 2:
print row
server_name = row[1]
specification_url = row[2]
availability = row[3]
comments = row[7]
if server_name in ['', '- // -']:
continue
if len(set(server_name).intersection(vendors)) > 0:
server_vendor = set(server_name).intersection(vendors)[0]
else:
server_vendor = " "
if row[3] not in ['', '?']:
nic_name = row[3]
nic_vendor = None
if len(set(nic_name).intersection(vendors)) > 0:
nic_vendor = set(nic_name).intersection(vendors)[0]
if nic_vendor is not None:
nic = Component(name=nic_name,
vendor=nic_vendor,
type="nic",
driver=default)
else:
nic = Component(name=nic_name,
type="nic",
driver=default)
if row[5] not in ['', '?']:
chipset_name = row[5]
chipset_vendor = None
if len(set(chipset_name).intersection(vendors)) > 0:
chipset_vendor = set(chipset_name).intersection(
vendors)[0]
if chipset_vendor is None:
chipset_vendor = " "
chipset = Component(name=repr(chipset_name),
vendor=chipset_vendor,
type="chipset",
driver=default)
s = Server(name=server_name,
specification_url=specification_url,
availability=availability,
comments=repr(comments),
vendor=server_vendor)
def savePeople(self):
alldata = self.grabAllData("people")
for data in alldata:
# get person from database
person = self.find_or_create(data, Person)
# get planet from database
planet = self.find_or_create(
json.loads(requests.get(data['homeworld']).text), Planet)
for v in data['vehicles']:
vehicle = self.find_or_create(json.loads(requests.get(v).text),
Vehicle)
try:
self.open().query(Driver).filter(
Driver.person == person,
Driver.vehicle == vehicle).one()
print("data already exist")
except:
driver = Driver()
driver.vehicle = vehicle
driver.person = person
self.save(driver)
print("Driver Vehicle saved")
for s in data['starships']:
starship = self.find_or_create(
json.loads(requests.get(s).text), Starship)
try:
self.open().query(Driver).filter(
Driver.person == person,
Driver.starship == starship).one()
print("data already exist")
except:
pilot = Pilot()
pilot.starship = starship
pilot.person = person
self.save(pilot)
print("Pilot Starships saved")
for f in data['films']:
film = self.find_or_create(json.loads(requests.get(f).text),
Film)
try:
self.open().query(Role).filter(Role.person == person,
Role.film == film).one()
print("data film already exist")
except:
role = Role()
role.film = film
role.person = person
self.save(role)
print("Role saved")
for s in data['species']:
species = self.find_or_create(json.loads(requests.get(s).text),
Species)
try:
self.open().query(Member).filter(
Member.person == person,
Member.species == species).one()
print("data species already exist")
except:
member = Member()
member.species = species
member.person = person
self.save(member)
print("Member saved")
print(planet)
if not person.homeworld:
person.homeworld = planet
self.save(person)
#add planet based on vehicle
vehicle = self.find_or_create(
json.loads(requests.get(data['homeworld']).text), Planet)
def create_driver(self):
return Driver('test')
sys.path.insert(0, "apps/python/ac_dashboard/DLLs")
SYSDIR = "stdlib64" if platform.architecture()[0] == "64bit" else "stdlib"
sys.path.insert(0, os.path.join(os.path.dirname(__file__), SYSDIR))
os.environ['PATH'] += ';.'
from sim_info import info
import info_app
from models import TelemetryProvider, Car, Driver
import dashboard_elements
import tyre_apps
except Exception as err:
ac.log("ac_dashboard: " + str(err))
import acsys
MAIN_APP_TELEMETRY = TelemetryProvider()
DRIVER = Driver(MAIN_APP_TELEMETRY)
CAR = Car(MAIN_APP_TELEMETRY)
def read_static_shared_memory():
global NUM_CARS
while not (info.static.maxFuel or info.static.maxRpm
or info.static.numCars):
continue # wait for both to be read
CAR.max_fuel = info.static.maxFuel
CAR.max_rpm = info.static.maxRpm
NUM_CARS = info.static.numCars
def acMain(ac_version):
"""Main function that is invoked by Assetto Corsa."""
def object_loader(self, input_data):
"""
parses through the input data
and loads it into the object data member
of this report engine class. Creates
a dictionary where the key is a driver object
and the value is a list of trips associated
with the driver.
"""
# two lists created for categorizing the input types
driver_list = list()
trip_list = list()
# iterate through the inputs
for input in input_data:
input_words = input.split()
# checks if the input command is driver or trip
# puts the command in the respective bucket
if input_words[0].lower().capitalize() == DRIVER:
driver_list.append(input)
elif input_words[0].lower().capitalize() == TRIP:
trip_list.append(input)
# iterate through the driver command list
# and make it a key for the object data
for driver_text in driver_list:
driver_data = driver_text.split()
driver_name = driver_data[1]
# create list of driver names for checking if name is in list
drive_obj_names = [
driver.name for driver, trip_list in self.object_data.items()
]
# if the driver name is not in the list, create a new key as the Driver object
if driver_name not in drive_obj_names:
new_driver = Driver(driver_name)
self.object_data[new_driver] = list()
# iterate through the trip commands
for trip_text in trip_list:
trip_data = trip_text.split()
text_trip_driver = trip_data[1]
text_start_time = trip_data[2]
text_end_time = trip_data[3]
text_distance = trip_data[4]
# create a new Trip object
new_trip = Trip(text_start_time, text_end_time, text_distance)
# iterate through object_data for checking on the name
for key, value in self.object_data.items():
# if the driver name and trip driver is the same
# append to the list of the trips for the object_data
if key.name == text_trip_driver:
self.object_data[key].append(new_trip)
# final iteration where the trips are added as children to the
# actual driver objects instead of just in the object_data structure
for driver_obj, trip_list in self.object_data.items():
for trip in trip_list:
driver_obj.add_trip(trip)
from models import Car, Driver, Garage, Manufacturer, Status, Station
import datetime
test_manufacturer = Manufacturer()
test_driver = Driver()
test_car = Car()
test_garage = Garage()
test_status = Status()
test_station = Station()
test_manufacturer = {
'id': 1,
'name': "Nissan",
'start_date': datetime.date(year=1933, month=12, day=26)
}
test_driver = {
'id': 1,
'name': "Sanic",
'birthday': datetime.date(year=2010, month=3, day=31)
}
test_car = {
'id': 1,
'on': False,
'doors': 2,
'color': 'black',
'make': test_manufacturer,
'passengers': [test_driver]
}
def process(self, command):
input_arr = command.split()
operationCommand = self._read_input(input_arr, 0)
operation = commands_to_operation_map.get(operationCommand)
if operation is None:
raise MalformedCommandError(command + " missing valid operation.")
if operation == "INIT":
try:
size = int(self._read_input(input_arr, 1))
except ValueError:
raise MalformedCommandError(
"{} is not int. Slot size should be int.".format(
input_arr[1]))
try:
num_slots = self.parking_lot_service.create_parking_lot_of_size(
size)
except ValueError as e:
raise MalformedCommandError(
"Lot size should be positive integer")
return "Created parking of {} slots".format(num_slots)
elif operation == "PARK":
if self._read_input(input_arr, 2) != "driver_age":
raise MalformedCommandError("Missing command arguments.")
number_plate = self._read_input(input_arr, 1)
try:
driver_age = int(self._read_input(input_arr, 3))
if driver_age <= 0:
raise MalformedCommandError(
"{} is negative. Age should be positive.".format(
input_arr[3]))
except ValueError:
raise MalformedCommandError(
"{} is not int. Drive age should be int.".format(
input_arr[3]))
driver = Driver(driver_age)
vehicle_to_park = Vehicle(number_plate, driver)
try:
parked_slot = self.parking_lot_service.park_vehicle(
vehicle_to_park)
return 'Car with vehicle registration number "{}" has been parked at slot number {}'.format(
parked_slot.parked_vehicle.number, parked_slot.number)
except DuplicateVehicleError as e:
return "Vehicle with this registration number is already parked."
except ParkingFullError as e:
return "Cannot park more vehicles because parking is full."
elif operation == "VEHICLE_NUM_TO_SLOT_NUM":
vehicle_number = self._read_input(input_arr, 1)
slot_num = self.parking_lot_service.get_slot_number_for_vehicle_number(
vehicle_number)
if slot_num is None:
return ""
return str(slot_num)
elif operation == "AGE_TO_SLOT_NUMS":
try:
age = int(self._read_input(input_arr, 1))
if age <= 0:
raise MalformedCommandError(
"{} is negative. Age should be positive.".format(
input_arr[1]))
except ValueError:
raise MalformedCommandError(
"{} is not int. Age should be int.".format(input_arr[1]))
slot_nums = self.parking_lot_service.get_slot_numbers_for_driver_age(
age)
return ",".join([str(item) for item in slot_nums])
elif operation == "AGE_TO_VEHICLE_NUMS":
try:
age = int(self._read_input(input_arr, 1))
if age <= 0:
raise MalformedCommandError(
"{} is negative. Age should be positive.".format(
input_arr[1]))
except ValueError:
raise MalformedCommandError(
"{} is not int. Age should be int.".format(input_arr[1]))
nums = self.parking_lot_service.get_parked_vehicle_numbers_of_driver_age(
age)
return ",".join([str(item) for item in nums])
elif operation == "UNPARK":
try:
slot_num = int(self._read_input(input_arr, 1))
if slot_num <= 0:
raise MalformedCommandError(
"{} is negative. Slot Number should be positive.".
format(input_arr[1]))
vehicle = self.parking_lot_service.empty_slot(slot_num)
except ValueError:
raise MalformedCommandError(
"{} is not int. Slot Number should be int.".format(
input_arr[1]))
except SlotNotPresentError:
return 'Slot number not present.'
if vehicle is None:
return "Slot already vacant"
return 'Slot number {} vacated, the car with vehicle registration number "{}" left the space, the driver of the car was of age {}'.format(
slot_num, vehicle.number, vehicle.driver.age)