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 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 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 save(entity):
if entity.key is None:
entity = Driver.save(entity)
else:
current = Driver.get(entity.key)
if current is not None:
# current.driver_phone = entity.driver_phone
# current.driver_email = entity.driver_email
# current.driver_id = entity.driver_id
# current.driver_operational = entity.driver_operational
# current.driver_name = entity.driver_name
entity = Driver.save(entity)
else:
raise ValueError("Driver does not exists")
return entity
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 get(self):
driver = int(self.request.get("edit"))
edit_driver = Driver.get_by_id(driver)
t = jinja_env.get_template("driveredit.html")
content = t.render(driver=edit_driver)
self.write(content)
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 post(self):
general_checkbox = self.request.get("general")
oil_checkbox = self.request.get("oil")
coolant_checkbox = self.request.get("coolant")
belts_checkbox = self.request.get("belts")
battery_checkbox = self.request.get("battery")
engine_checkbox = self.request.get("engine")
gauges_checkbox = self.request.get("gauges")
wipers_checkbox = self.request.get("wipers")
horn_checkbox = self.request.get("horn")
heat_checkbox = self.request.get("heat")
mirrors_checkbox = self.request.get("mirrors")
steering_checkbox = self.request.get("steering")
brakes_checkbox = self.request.get("brakes")
ebrake_checkbox = self.request.get("ebrake")
seatbelts_checkbox = self.request.get("seatbelts")
safety_checkbox = self.request.get("safety")
lights_checkbox = self.request.get("lights")
reflectors_checkbox = self.request.get("reflectors")
suspension_checkbox = self.request.get("suspension")
tires_checkbox = self.request.get("tires")
exhaust_checkbox = self.request.get("exhaust")
wheels_checkbox = self.request.get("wheels")
exbrakes_checkbox = self.request.get("exbrakes")
action_checkbox = self.request.get("action")
form_num = self.request.get("formnum")
current_vehicle = self.request.get("vehicle")
current_driver = self.request.get("driver")
checkboxes = [
general_checkbox, oil_checkbox, coolant_checkbox, belts_checkbox,
battery_checkbox, engine_checkbox, gauges_checkbox,
wipers_checkbox, horn_checkbox, heat_checkbox, mirrors_checkbox,
steering_checkbox, brakes_checkbox, ebrake_checkbox,
seatbelts_checkbox, safety_checkbox, lights_checkbox,
reflectors_checkbox, suspension_checkbox, tires_checkbox,
exhaust_checkbox, wheels_checkbox, exbrakes_checkbox
]
action_items = []
vehicle = Vehicle.get_by_id(int(current_vehicle))
driver = Driver.get_by_id(int(current_driver))
for i in checkboxes:
if i != "":
action_items.append(i)
#if action_items != []:
#vehicle.maintreq = True
#vehicle.put()
#else:
#form = Inspection(formnum = form_num, items = "No maintenance required",
#vehicle = vehicle)
#form.put()
t = jinja_env.get_template("inspectdetails.html")
response = t.render(action_items=action_items,
form_num=form_num,
vehicle=vehicle,
driver=driver)
self.write(response)
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_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 post(self):
driver = int(self.request.get("delete"))
delete_driver = Driver.get_by_id(driver)
delete_driver.delete()
t = jinja_env.get_template("delete-confirm.html")
content = t.render(driver=delete_driver)
self.write(content)
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 post(self):
driver = int(self.request.get("driver"))
edit_driver = Driver.get_by_id(driver)
name = self.request.get("name")
employeeid = int(self.request.get("employeeid"))
edit_driver.name = name
edit_driver.employeeid = employeeid
edit_driver.put()
self.redirect('/drivers')
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 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 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 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 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 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 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 get(self):
current_vehicle = self.request.get("vehicle")
current_driver = self.request.get("driver")
vehicle = Vehicle.get_by_id(int(current_vehicle))
driver = Driver.get_by_id(int(current_driver))
drivetype = type(current_driver)
month = str(datetime.today().month)
year = str(datetime.today().year)
rand_num = str(random.randint(100, 999))
today = rand_num + month + year
t = jinja_env.get_template("inspectdetails.html")
response = t.render(type=drivetype,
driver=driver,
vehicle=vehicle,
date=datetime.now(),
formid=today)
self.write(response)
def update_component(servers=None,
type=None,
name=None,
vendor=None,
comments=None,
hw_id=None,
driver=None):
component = get(c for c in Component if c.name == name)
if servers:
servers = select(s for s in Server if s.name in servers)[:]
component.servers.clear()
for s in servers:
component.servers.add(s)
if type is not None and check_type(type):
component.type = type
if name is not None:
component.name = name
if vendor is not None:
component.vendor = vendor
if comments is not None:
component.comments = comments
if hw_id is not None:
component.hw_id = hw_id
if driver is not None:
driver = Driver.get(lambda d: d.name == driver)
if driver is not None:
component.driver = driver
return component
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 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)
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]
}
# all the imports
from flask import Flask
from flask_peewee.db import Database
# create our little application :)
app = Flask(__name__)
app.config.from_object('drivers.config')
# instantiate the db wrapper
db = Database(app)
from models import Driver
if Driver.table_exists() == False:
Driver.create_table()
Driver.create(username='******', email='*****@*****.**',
password='******', is_admin=True, name='Admin')
import drivers.routes
import drivers.api
