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_polymorphic_generator_one_relationship_readme_example(self):
db.create_all()
org1 = Org()
dealer1 = LocalDealer() # SQLAlchemy model
dealer2 = Dealer.find(id=3) # Network backed model
db.session.add(org1)
db.session.add(dealer1)
# We flush to get the ID of org1 and dealer1
db.session.flush()
vehicle1 = Vehicle(source=org1)
vehicle2 = Vehicle(source=dealer1)
vehicle3 = Vehicle(source=org1)
vehicle4 = Vehicle(source=org1)
vehicle5 = Vehicle(source=dealer2)
assert vehicle1.source == org1
assert vehicle1.source_id == 1
assert vehicle2.source_type == 'local_dealer'
assert org1.vehicles == [vehicle1, vehicle3, vehicle4]
assert vehicle5.source == dealer2
assert vehicle5.source_type == 'dealer'
db.session.flush()
db.session.rollback()
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):
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 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 saveVehicle(self):
alldata = self.grabAllData("vehicles")
for data in alldata:
savingdata = Vehicle()
savingdata.parse(data)
self.save(savingdata)
return savingdata
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 init_db():
booking1 = Booking(
booking_price=66.6,
start_time=datetime(2020, 3, 1, 0, 0 ,0),
end_time=datetime(2020, 3, 4, 0, 0 ,0)
)
booking1.save()
booking2 = Booking(
booking_price=55.5,
start_time=datetime(2020, 3, 5, 0, 0 ,0),
end_time=datetime(2020, 3, 7, 0, 0 ,0)
)
booking2.save()
vehicle1 = Vehicle(
type="small car",
make="Honda",
model="Civic R",
year=2020,
registration_tag="A12345",
current_mileage=123.12,
condition="like new",
capacity=4,
is_available=True,
booking=[booking1, booking2]
)
vehicle1.save()
def test_constructor(self):
"""
Test Vehicle class generation
"""
# veh_par = VehParameter()
veh_1 = Vehicle()
self.assertTrue(isinstance(veh_1, Vehicle))
self.assertEqual(veh_1.n_veh, 1)
def populate_vehicles(cur):
cur.execute("SELECT * FROM vehicles LIMIT 1000;")
vehicles = []
vehicles_table = cur.fetchall()
for vehicles_row in vehicles_table:
vehicle = Vehicle(vehicles_row)
vehicles.append(vehicle)
return vehicles
def create_vehicle():
request_body_vehicle = request.get_json()
newVehicle = Vehicle(brand=request_body_vehicle["brand"], capacity=request_body_vehicle["capacity"], color=request_body_vehicle["color"])
db.session.add(newVehicle)
db.session.commit()
return jsonify(request_body_vehicle), 200
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 test_single_table_inheritence(self):
db.create_all()
ads1 = AdsData()
news1 = NewsData()
db.session.add(ads1)
db.session.add(news1)
db.session.flush()
vehicle1 = Vehicle(source=ads1)
vehicle2 = Vehicle(source=ads1)
vehicle3 = Vehicle(source=news1)
assert vehicle1.source == ads1
assert vehicle1.source_id == 1
assert vehicle1.source_type == "ads_data"
assert ads1.vehicles == [vehicle1, vehicle2]
assert news1.vehicles == [vehicle3]
db.session.flush()
db.session.rollback()
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 create_vehicle(quantity, price, type, user_id):
vehicle = Vehicle(type=type,
charge=price,
quantity=quantity,
user_id=user_id,
status="FREE")
db.session.add(vehicle)
db.session.commit()
db.session.refresh(vehicle)
return vehicle
def add_vehicle_helper(session, city, owner_id, current_location, type, vehicle_metadata, status):
vehicle_type = type
vehicle = Vehicle(id=MovRGenerator.generate_uuid(), type=vehicle_type,
city=city, owner_id=owner_id, current_location = current_location,
status=status,
ext=vehicle_metadata)
session.add(vehicle)
return {'city': vehicle.city, 'id': vehicle.id}
def findVehicleValue(lookupVin):
# Don't Forget To Replace This With Your Own API Key
# You will need to add a api key file to reference this, or
# paste it in as a string at your own risk.
api_key = api_keys.key
# VinAudit lets you specify a milage as well, you could easily
# add an additional spreadsheet field and pull specific values
# with an actual vehicle mileage.
# #####
# For my purposes, I've left the average mileage attribute because
# the lists I run generally don't have a users upto date vehicle
# mileage.
response = requests.get(
'http://marketvaluev1.vinaudit.com/getmarketvalue.php',
params={
'key': api_key,
'vin': lookupVin,
'format': 'xml',
'period': '90',
'mileage': 'average'
})
soup = BeautifulSoup(response.text, 'xml')
# BS4 by default returns an object, so you want to seperate that to a string for use later in thhe
# main program.
current_vin = soup.find('vin').string
current_details = soup.find('vehicle').string
current_mileage = soup.find('mileage').string
current_certainty = soup.find('certainty').string
current_mean = soup.find('mean').string
current_average_price = soup.find('average').string
current_below_price = soup.find('below').string
# Builds the object and returns it at the end of the program to be
# added to a list.
# I've built a more robust object that will utilize the full response from the API -- You may use any of these attributes
# to build a database of customer vehicle information simply from their vin # with these attributes.
vehicle = Vehicle(current_vin, current_details, current_mileage,
current_certainty, current_mean, current_average_price,
current_below_price)
# valueList = [current_vin,current_details,current_mileage,current_certainty,current_mean,current_average_price,current_below_price]
# Very useful for checking a vehicles value as the program is running.
print(vehicle.averagePrice)
return vehicle
def vehicles(id=None):
if request.method == 'GET':
if id is not None:
vehicle = Vehicle.query.get(id)
if not vehicle:
return jsonify({"fail": "Vehicle not found"}), 404
return jsonify({
"success": "Vehicle found",
"vehicle": vehicle.serialize()
}), 200
else:
vehicles = Vehicle.query.all()
vehicles = list(map(lambda vehicle: vehicle.serialize(), vehicles))
return jsonify({
"total": len(vehicles),
"results": vehicles
}), 200
if request.method == 'POST':
name = request.json.get('name')
model = request.json.get('model')
vehicle_class = request.json.get('vehicle_class')
crew = request.json.get('crew')
manufacturer = request.json.get('manufacturer')
cargo_capacity = request.json.get('cargo_capacity')
cost_in_credits = request.json.get('cost_in_credits')
consumables = request.json.get('consumables')
vehicle = Vehicle()
vehicle.name = name
vehicle.model = model
vehicle.vehicle_class = vehicle_class
vehicle.crew = crew
vehicle.manufacturer = manufacturer
vehicle.cargo_capacity = cargo_capacity
vehicle.cost_in_credits = cost_in_credits
vehicle.consumables = consumables
vehicle.save()
return jsonify({
"success": "vehicle created!",
"vehicle": vehicle.serialize()
}), 201
if request.method == 'PUT':
pass
if request.method == 'DELETE':
vehicle = Vehicle.query.get(id)
if not vehicle:
return jsonify({"fail": "vehicle not found"}), 404
vehicle.delete()
return jsonify({"success": "vehicle deleted"}), 200
def addVehicle(_, info, vehicle_type, **kwargs):
new_dict = kwargs
target_location = None
if ('location_id' in new_dict):
target_location = Location.objects(id=new_dict['location_id']).first()
new_dict.pop('location_id')
vehicle_type = Vehicletype.objects(id=vehicle_type).first()
vehicle = Vehicle(location=target_location, **new_dict)
vehicle.vehicle_type = vehicle_type
vehicle.save()
return vehicle
def save_vehicles(route, acessible, prefix):
try:
vehicle = Vehicle.objects.get(prefix=prefix)
vehicle.acessible = acessible
except Vehicle.DoesNotExist:
vehicle = Vehicle(
route=route,
acessible=acessible,
prefix=prefix,
)
vehicle.save()
return vehicle
def create_neo_db():
# Create temporary station and vehicle
tmp_station = Station(short='STATI',
name='Station',
latitude=10.0,
longitude=10.0).save()
tmp_vehicle = Vehicle(code='100').save()
spatial_query = "CALL spatial.addPointLayer('spati')"
neo_db.cypher_query(query=spatial_query)
tmp_station.delete()
tmp_vehicle.delete()
def add_vehicles_helper(sess, chunk, n):
owners = sess.query(User).filter_by(city=city).all()
vehicles = []
for i in range(chunk, n):
vehicle_type = MovRGenerator.generate_random_vehicle()
vehicles.append(Vehicle(id=MovRGenerator.generate_uuid(),
type=vehicle_type,
city=city,
current_location=datagen.address(),
owner_id=(random.choice(owners)).id,
status=MovRGenerator.get_vehicle_availability(),
ext=MovRGenerator.generate_vehicle_metadata(vehicle_type)))
sess.bulk_save_objects(vehicles)
def add_vehicle():
form = AddVehicleForm()
if form.validate_on_submit():
name = request.form['name']
year = request.form['year']
make = request.form['make']
model = request.form['model']
user_id = current_user.id
vehicle = Vehicle(name=name, year=year, make=make, model=model, user_id=user_id)
db.session.add(vehicle)
db.session.commit()
return redirect(url_for('home'))
return render_template('add_vehicle.html', form=form)
class StaticVehicleModel(factory.django.DjangoModelFactory):
"""
Creates Vehicle Object using Admin preiveldges. POSTS to DATABASE for quoting
tool application.
"""
class Meta:
model = Vehicle
mustang = Vehicle(model_name="mustang",
engine=Engine("v8", "clean cut", 19000),
exterior_color=ExteriorColor("white", 2500),
wheels=Wheel("chrome", "shiny", 4000),
interior_package=InteriorColor("default", 2000),
audio_system=AudioSound("radio", "simple system", 1000))
mustang.save()
def get_vehicles():
count = get_count('vehicles')
for vehicle_id in range(1, count + 1):
url = SWAPI_URL.format('vehicles') + '{}/'.format(vehicle_id)
vehicle = None
try:
vehicle = DB.open().query(Vehicle).filter(
Vehicle.api_url == url).one()
except:
obj = get_request(url)
if 'name' in obj:
vehicle = Vehicle()
vehicle.parse_json(obj)
DB.save(vehicle)
if vehicle:
print(vehicle.name)
print('+++++++++++++++++')
def list_addAll():
body = request.get_json()
people = body["people"]
planet = body["planet"]
vehicle = body["vehicle"]
for p in people:
people1 = People(
name=p["Character name"],
height=p["Character height"],
mass=p["Character mass"],
hair_color=p["Character hair_color"],
skin_color=p["Character skin color"],
eye_color=p["Character eye color"],
birth_year=p["Character birth year"],
gender=p["Character gender"],
)
db.session.add(people1)
for pl in planet:
planet1 = Planet(
planet_name=pl["Planet name"],
rotation_period=pl["Rotation period"],
orbital_period=pl["Orbital period"],
diameter=pl["Diameter"],
climate=pl["Climate"],
gravity=pl["Gravity"],
terrain=pl["Terrain"],
population=pl["Population"],
)
db.session.add(planet1)
for v in planet:
vehicle1 = Vehicle(
vehicle_name=v["Vehicle name"],
model=v["Model"],
passenger=v["Passenger"],
consumable=v["Consumable"],
starship_class=v["Starship class"],
lenght=v["Lenght"],
cargo_capacity=v["Cargo capacity"],
hyperdrive_rating=v["Hyperdrive rating"],
)
db.session.add(vehicle1)
db.session.commit()
def add_vehicle(request):
"""
View to add a new vehicle to upspot.
"""
if request.method == 'GET':
vehicles = Vehicle.objects.filter(owner=request.user)
return render(request, 'park/vehicle.html', {'vehicles': vehicles})
elif request.method == 'POST':
owner = request.user
make = request.POST.get("make")
model = request.POST.get("model")
new_vehicle = Vehicle()
new_vehicle.owner = owner
new_vehicle.make = make
new_vehicle.model = model
new_vehicle.save()
return redirect('/park/vehicles')
def add_cars():
body = request.form
try:
vehicle = Vehicle(brand=body.get('brand', None),
model=body.get('model', None),
doors=body.get('doors', None),
vtype=body.get('vtype', None),
year=body.get('year', 0),
power=body.get('power', 0),
licence=body.get('licence', ''),
transmission=body.get('transmission', ''),
category=body.get('category', ''))
vehicle.insert()
return redirect(url_for('vehicle_by_id', vehicle_id=vehicle.id))
except:
abort(422)
def create_dict_for_update(JSONDoc):
modified_vehicles = []
for k, v in JSONDoc.iteritems():
if k == 'vehicles':
# print(k, v)
# for vehicle, customer_vehicle in zip(v, CustomerObject.vehicles):
# print("VEHICLE " + str(vehicle))
# for v_key, v_value in vehicle.iteritems():
# v_key = "set__" + str(v_key)
# print(v_key)
# customer_vehicle.update(**vehicle)
for vehicle in v:
v_obj = Vehicle()
v_obj.vehicle_type = vehicle['vehicle_type']
v_obj.vehicle_number = vehicle['vehicle_number']
v_obj.vehicle_rc_link = vehicle['vehicle_rc_link']
v_obj.save()
modified_vehicles.append(v_obj)
k = "set__" + str(k)
return JSONDoc, modified_vehicles
