def update_vehicle(vehicle_number, supplier_id, owner_id, driver_id, vehicle_category_id, user):
vehicle = get_or_none(Vehicle, vehicle_number=compare_format(vehicle_number))
supplier = get_or_none(Supplier, id=supplier_id)
owner = get_or_none(Supplier, id=owner_id)
driver = get_or_none(Driver, id=driver_id)
vehicle_type = get_or_none(VehicleCategory, id=vehicle_category_id)
if not isinstance(vehicle, Vehicle):
vehicle_serializer = VehicleSerializer(
data={'vehicle_number': compare_format(vehicle_number),
'vehicle_type': vehicle_type.id if isinstance(vehicle_type, VehicleCategory) else None,
'created_by': user,
'changed_by': user})
if vehicle_serializer.is_valid():
vehicle = vehicle_serializer.save()
else:
return False
if isinstance(vehicle, Vehicle):
if not isinstance(vehicle.vehicle_type, VehicleCategory) and isinstance(vehicle_type, VehicleCategory):
vehicle_serializer = VehicleSerializer(instance=vehicle, partial=True,
data={'vehicle_type': vehicle_type.id})
if vehicle_serializer.is_valid():
vehicle_serializer.save()
else:
return False
if isinstance(owner, Supplier) and not SupplierVehicle.objects.filter(
vehicle=vehicle, ownership='O', active=True).exists():
supplier_vehicle_serializer = SupplierVehicleSerializer(data={
'ownership': 'O', 'supplier': owner_id, 'vehicle': vehicle.id, 'created_by': user,
'changed_by': user})
if supplier_vehicle_serializer.is_valid():
supplier_vehicle_serializer.save()
else:
return False
if supplier != owner and isinstance(supplier, Supplier) and not SupplierVehicle.objects.filter(
vehicle=vehicle, supplier=supplier, ownership='B',
active=True).exists() and not SupplierVehicle.objects.filter(
vehicle=vehicle, supplier=supplier, ownership='O', active=True).exists():
supplier_vehicle_serializer = SupplierVehicleSerializer(data={
'ownership': 'B', 'supplier': supplier_id, 'vehicle': vehicle.id, 'created_by': user,
'changed_by': user})
if supplier_vehicle_serializer.is_valid():
supplier_vehicle_serializer.save()
else:
return False
if isinstance(driver, Driver) and not DriverVehicle.objects.filter(
driver=driver, vehicle=vehicle, active=True).exists():
driver_vehicle_serializer = DriverVehicleSerializer(
data={'driver': driver.id, 'vehicle': vehicle.id, 'active': True, 'created_by': user,
'changed_by': user})
if driver_vehicle_serializer.is_valid():
driver_vehicle_serializer.save()
else:
return False
else:
return False
return True
def update_tempogo_devices():
for user in TEMPOGO_USERS:
config = get_config(client_id=user['client_id'],
client_secret_id=user['client_secret_id'])
client_id = config['clientId']
client_secret = config['clientSecret']
client = BackendApplicationClient(client_id=client_id)
oauth = OAuth2Session(client=client)
token = oauth.fetch_token(token_url=config['accessTokenUri'],
client_id=client_id,
client_secret=client_secret)
server_response = oauth.get(config['vehiclesUri'])
json_response = server_response.json()
if json_response['status']:
for response in json_response['data']:
if not Vehicle.objects.filter(
vehicle_number__iexact=compare_format(
response['registration_number'])).exists():
vehicle_serializer = VehicleSerializer(
data={
'vehicle_number':
compare_format(response['registration_number']),
'changed_by':
'*****@*****.**'
})
if vehicle_serializer.is_valid():
vehicle_serializer.save()
vehicle = get_or_none(Vehicle,
vehicle_number=compare_format(
response['registration_number']))
if isinstance(vehicle, Vehicle):
is_driver = isinstance(vehicle.driver, Driver)
vehicle_serializer = VehicleSerializer(
instance=vehicle).data
tempogo_device_serializer = TempoGoGPSDeviceSerializer(
data=dict(
device_id=response['id'],
imei=response['imei'],
driver_name=vehicle_serializer['driver_data']
['name'] if is_driver else None,
driver_number=vehicle_serializer['driver_data']
['phone'] if is_driver else None,
driving_licence_number=vehicle_serializer[
'driver_data']['dl_number'],
driver=vehicle_serializer['driver_data']['id']
if is_driver else None,
vehicle_number=vehicle_serializer['vehicle_number'],
changed_by='*****@*****.**'))
if tempogo_device_serializer.is_valid():
pass
print(tempogo_device_serializer.errors)
def register_vehicle(request):
if Vehicle.objects.filter(vehicle_number=compare_format(
request.POST.get('vehicle_number'))).exists():
return json_error_response(msg="Vehicle Already Exists", status=409)
owner = get_or_none(Owner,
id=int_or_none(request.POST.get('owner_id', None)))
vehicle = Vehicle.objects.create(
owner=owner,
vehicle_number=compare_format(request.POST.get('vehicle_number')),
rc_number=request.POST.get('rc_number'),
permit=request.POST.get('permit_number'),
permit_validity=django_date_format(
request.POST.get('permit_validity')),
permit_type=request.POST.get('permit_type'),
vehicle_type=get_or_none(VehicleCategory,
id=int_or_none(
request.POST.get('vehicle_category'))),
vehicle_capacity=to_int(request.POST.get('exact_vehicle_capacity')),
body_type=request.POST.get('vehicle_body_type'),
vehicle_model=request.POST.get('vehicle_model'),
chassis_number=request.POST.get('chassis_number'),
engine_number=request.POST.get('engine_number'),
insurer=request.POST.get('insurer'),
insurance_number=request.POST.get('insurance_number'),
insurance_validity=django_date_format(
request.POST.get('insurance_validity')),
registration_year=None if not request.POST.get('registration_year')
else django_date_format('01-Jan-' +
request.POST.get('registration_year').strip()),
registration_validity=django_date_format(
request.POST.get('registration_validity')),
fitness_certificate_number=request.POST.get(
'fitness_certificate_number'),
fitness_certificate_issued_on=django_date_format(
request.POST.get('fitness_certificate_issued_on')),
fitness_certificate_validity_date=django_date_format(
request.POST.get('fitness_certificate_validity')),
puc_certificate_number=request.POST.get('puc_certificate_number'),
puc_certificate_issued_on=django_date_format(
request.POST.get('puc_certificate_issued_on')),
puc_certificate_validity_date=django_date_format(
request.POST.get('puc_certificate_validity')),
gps_enabled=False if request.POST.get('gps_enable') == 'no' else True,
changed_by=request.user)
if owner:
create_broker_owner(owner=owner)
broker = Broker.objects.get(name=owner.name)
update_broker_vehicle(broker=broker, vehicle=vehicle)
return json_success_response(msg="Success")
def update_supplier_vehicle_data():
for supplier in Supplier.objects.filter(id__gte=2754):
broker = get_or_none(Broker, name=supplier.user)
owner = get_or_none(Owner, name=supplier.user)
if isinstance(owner, Owner):
supplier.pan = owner.pan
supplier.save()
for ov in owner.vehicle_owner.all():
s_vehicle = get_or_none(s_Vehicle, vehicle_number=ov.vehicle_number)
if isinstance(s_vehicle, s_Vehicle):
SupplierVehicle.objects.create(
supplier=supplier,
ownership='O',
vehicle=s_vehicle,
created_by=User.objects.get(username='******'),
changed_by=User.objects.get(username='******')
)
if isinstance(broker, Broker):
for bv in broker.broker_vehicle.all():
vehicle_number = compare_format(bv.vehicle.vehicle_number)
s_vehicle = get_or_none(s_Vehicle, vehicle_number=vehicle_number)
if isinstance(s_vehicle, s_Vehicle) and not SupplierVehicle.objects.filter(supplier=supplier,
vehicle=s_vehicle,
ownership='B').exists():
SupplierVehicle.objects.create(supplier=supplier, vehicle=s_vehicle, ownership='B')
def parse_secugps(html_data):
table = BeautifulSoup(html_data, 'lxml')
table = table.tbody
records = []
for tr in table.findAll("tr"):
trs = tr.findAll("td")
record = []
try:
record.append((compare_format(trs[2].text).replace('\n', '')))
record.append(trs[3].text)
record.append(re.findall(r'\d+', trs[2].a['onclick'])[0])
record.append('|'.join([
re.findall(r'\d+', trs[2].a['onclick'])[0],
((trs[2].text).replace('\n', ''))
]))
record.append(trs[4].text)
address = trs[8].text.replace('\t', '').strip()
record.append(re.sub(r'\(.*\)', '', address))
location = ((trs[9].a['href'])[38:]).split(',')
record.append(float(location[0]))
record.append(float(location[1]))
records.append(record)
except IndexError:
# print tr
pass
df = pd.DataFrame(data=records,
columns=[
'vehicle_number', 'status', 'imei', 'deviceID',
'Total Kms', 'address', 'latitude', 'longitude'
])
return df
def create_vehicles():
for vehicle in o_Vehicle.objects.all():
if not s_Vehicle.objects.filter(vehicle_number=compare_format(vehicle.vehicle_number)).exists():
print(vehicle)
s_vehicle = s_Vehicle.objects.create(
vehicle_number=compare_format(vehicle.vehicle_number),
vehicle_type=vehicle.vehicle_type,
vehicle_capacity=vehicle.vehicle_capacity,
created_by=User.objects.get(username='******'),
changed_by=User.objects.get(username='******')
)
if vehicle.driver and s_Driver.objects.filter(user__profile__phone=vehicle.driver.phone).exists():
DriverVehicle.objects.create(
driver=s_Driver.objects.get(user__profile__phone=vehicle.driver.phone),
vehicle=s_vehicle,
created_by=User.objects.get(username='******'),
changed_by=User.objects.get(username='******')
)
def vehicle_booking_update():
for booking in ManualBooking.objects.all():
try:
vehicle = Vehicle.objects.get(
vehicle_number=compare_format(booking.lorry_number))
booking.vehicle = vehicle
booking.save()
except Vehicle.DoesNotExist:
print(booking.lorry_number)
def update_vehicle_fk():
for booking in ManualBooking.objects.filter(vehicle=None):
try:
vehicle = Vehicle.objects.get(
vehicle_number=compare_format(booking.lorry_number))
if isinstance(vehicle, Vehicle) and not isinstance(
booking.vehicle, Vehicle):
booking.vehicle = vehicle
booking.save()
else:
pass
except Vehicle.DoesNotExist:
if booking.lorry_number != 'NA':
vehicle = Vehicle.objects.create(
vehicle_number=compare_format(booking.lorry_number),
vehicle_type=VehicleCategory.objects.get(id=74))
booking.vehicle = vehicle
booking.save()
def save_vehicle_details(vehicle_number, vehicle_category_id, supplier, owner,
driver):
vehicle_category = get_or_none(VehicleCategory, id=vehicle_category_id)
try:
vehicle = Vehicle.objects.get(
vehicle_number=compare_format(vehicle_number))
except Vehicle.DoesNotExist:
vehicle = Vehicle.objects.create(
vehicle_number=compare_format(vehicle_number),
vehicle_type=vehicle_category,
)
update_vehicle_details(vehicle=vehicle,
supplier=supplier,
owner=owner,
driver=driver,
vehicle_category=vehicle_category)
create_broker_driver(supplier=supplier, driver=driver)
vehicle.save()
def update_vehicle_data(data):
for row in data:
vehicle = get_or_none(Vehicle, rc_number=compare_format(row['vehList']))
try:
MahindraGPSDevice.objects.get(device_id=compare_format(row['vehList']))
MahindraGPSDevice.objects.filter(device_id=compare_format(row['vehList'])).update(
imei=None,
driver_name=vehicle.driver.name if vehicle.driver else None,
driver_number=vehicle.driver.phone if vehicle.driver else None,
driver=vehicle.driver,
driving_licence_number=vehicle.driver.driving_licence_number if vehicle.driver else None,
vehicle_number=vehicle.vehicle_number,
vehicle_type=row['vehType'],
vehicle_status=row['StatusName'],
location_time=datetime.datetime.now(),
latitude=row['latitude'],
longitude=row['longitude'],
address=None,
status=row['StatusName']
)
except MahindraGPSDevice.DoesNotExist:
MahindraGPSDevice.objects.create(
device_id=compare_format(row['vehList']),
imei=None,
driver_name=vehicle.driver.name if vehicle.driver else None,
driver_number=vehicle.driver.phone if vehicle.driver else None,
driver=vehicle.driver,
driving_licence_number=vehicle.driver.driving_licence_number if vehicle.driver else None,
vehicle_number=vehicle.vehicle_number,
vehicle_type=row['vehType'],
vehicle_status=row['StatusName'],
location_time=datetime.datetime.now(),
latitude=row['latitude'],
longitude=row['longitude'],
address=None,
status=row['StatusName']
)
def vehicle_data(request):
vehicle_id = request.GET.get('vehicle_id')
vehicle_number_pattern = re.compile(VEHICLE_NUMBER[1:-2], re.IGNORECASE)
if vehicle_id.isdigit():
if isinstance(get_or_none(Vehicle, id=vehicle_id), Vehicle):
vehicle = Vehicle.objects.get(id=vehicle_id)
else:
return json_error_response(
msg="{} does not exits".format(vehicle_id), status=400)
elif isinstance(vehicle_id, str):
if vehicle_number_pattern.match(vehicle_id):
if Vehicle.objects.filter(
vehicle_number=compare_format(vehicle_id)).exists():
vehicle = Vehicle.objects.filter(
vehicle_number=compare_format(vehicle_id)).latest('id')
else:
return json_error_response(
msg="{} does not exits".format(vehicle_id), status=400)
else:
vehicle = None
else:
vehicle = None
if isinstance(vehicle, Vehicle):
data = {}
if vehicle.owner:
data['owner'] = {
'id': vehicle.owner.id,
'name': vehicle.owner.get_name(),
'phone': vehicle.owner.get_phone()
}
else:
data['owner'] = {}
if vehicle.vehicle_type:
data['vehicle_category'] = {
'id': vehicle.vehicle_type.id,
'vehicle_category': vehicle.vehicle_type.vehicle_category
}
else:
data['vehicle_category'] = {}
return json_success_response(msg=data)
else:
return json_400_incorrect_use()
def create_broker_vehicle():
for supplier in Supplier.objects.all():
broker = get_or_none(Broker, name=supplier.user)
if isinstance(broker, Broker):
for bv in broker.broker_vehicle.all():
vehicle_number = compare_format(bv.vehicle.vehicle_number)
s_vehicle = get_or_none(s_Vehicle, vehicle_number=vehicle_number)
if isinstance(s_vehicle, s_Vehicle) and not SupplierVehicle.objects.filter(supplier=supplier,
vehicle=s_vehicle,
ownership='B').exists():
SupplierVehicle.objects.create(supplier=supplier, vehicle=s_vehicle, ownership='B')
def merge_owner_data():
oo = Owner.objects.get(id=2305)
do = Owner.objects.get(id=2243)
supplier = get_or_none(Supplier, user=oo.name)
for vehicle in do.vehicle_owner.all():
s_vehicle = get_or_none(s_Vehicle, vehicle_number=compare_format(vehicle.vehicle_number))
if isinstance(s_vehicle, s_Vehicle):
if not SupplierVehicle.objects.filter(vehicle=s_vehicle, ownership='O').exists():
SupplierVehicle.objects.create(vehicle=s_vehicle, supplier=supplier,
ownership='O',
created_by=User.objects.get(username='******'),
changed_by=User.objects.get(username='******'))
def update_booking_vehicle_category():
bookings = ManualBooking.objects.filter(vehicle_category=None)
for booking in bookings:
try:
vehicle = Vehicle.objects.get(
vehicle_number=compare_format(booking.lorry_number))
if isinstance(vehicle.vehicle_type,
VehicleCategory) and not booking.vehicle_category:
booking.vehicle_category = vehicle.vehicle_type
booking.save()
except Vehicle.DoesNotExist:
pass
def team_booking_data(request, vehicle_id):
print(request.data)
if to_int(vehicle_id) != 9999999 and isinstance(get_or_none(Vehicle, id=vehicle_id), Vehicle):
vehicle = get_or_none(Vehicle, id=vehicle_id)
bookings = ManualBooking.objects.filter(
lorry_number__in=[display_format(compare_format(vehicle.vehicle_number))]).exclude(
booking_status__icontains='cancelled').order_by('-shipment_date')
else:
broker = Broker.objects.get(name=User.objects.get(username=request.user.username))
bookings = ManualBooking.objects.filter(supplier=broker,
shipment_date__gte=datetime(2017, 12, 1).date()).exclude(
booking_status__icontains='cancelled').order_by('-shipment_date')
return json_response({'status': 'success', 'data': supplier_booking_data(bookings=bookings)})
def parse_waytracker_data(html_data):
table = BeautifulSoup(html_data, 'lxml')
table = table.tbody
records = []
for tr in table.findAll("tr"):
trs = tr.findAll("td")
gps = ((trs[3].a['onclick'])[14:-7]).split(',')
records.append({
"latitude": to_float(gps[0]),
"longitude": to_float(gps[1]),
"vehicle_id": compare_format(gps[4].replace("'", "")),
"sno": gps[3].replace("'", ""),
"vehicle_no": compare_format(gps[4].replace("'", "")),
"datetime": datetime.strptime(trs[4].text, '%d %b %Y %H:%M'),
"engine_on": (trs[5].text).lower() != 'off',
"fuel": trs[6].text,
"nearest_site": trs[8].text,
"nearest_location": trs[9].text,
"speed": trs[10].text,
"idle_time": trs[11].text}
)
return records
def manual_booking_data():
data = []
for booking in ManualBooking.objects.exclude(booking_status='cancelled'):
try:
vehicle = Vehicle.objects.get(vehicle_number=compare_format(booking.lorry_number))
vehhicle_type = vehicle.vehicle_type.get_name() if vehicle.vehicle_type else ''
except Vehicle.DoesNotExist:
vehhicle_type = ''
data.append([
booking.id,
booking.booking_id,
booking.lorry_number,
booking.type_of_vehicle
])
def update_location_data(data):
for row in data:
vehicle = get_or_none(Vehicle, rc_number=compare_format(row['vehList']))
if vehicle:
MahindraGPSDeviceLog.objects.create(
device=get_or_none(MahindraGPSDevice, device_id=compare_format(row['vehList'])),
datetime=datetime.datetime.now(),
vehicle_id=None if not vehicle else vehicle.vehicle_number,
latitude=row['latitude'],
longitude=row['longitude'],
speed=0,
fuel_efficiency=row['FuelEfficency'],
address=None,
status=row['StatusName'],
# driver and vehicle info
driver_name=vehicle.driver.name if vehicle.driver else None,
driver_number=vehicle.driver.phone if vehicle.driver else None,
driving_licence_number=vehicle.driver.driving_licence_number if vehicle.driver else None,
vehicle_number=vehicle.vehicle_number,
vehicle_type=row['vehType'],
vehicle_status=row['StatusName']
)
def update_vehicle(broker_vehicle_id, vehicle_number, supplier, vehicle_owner,
driver, vehicle_type):
broker_vehicle = get_or_none(BrokerVehicle, id=broker_vehicle_id)
if broker_vehicle:
broker_vehicle.broker = get_or_none(Broker, id=supplier)
broker_vehicle.save()
vehicle = get_or_none(Vehicle,
vehicle_number=compare_format(vehicle_number))
if vehicle:
driver = None if not driver else get_or_none(Driver, id=driver)
Vehicle.objects.filter(driver=driver).update(driver=None)
vehicle.driver = driver
vehicle.owner = None if not vehicle_owner else get_or_none(
Owner, id=vehicle_owner)
# vehicle.vehicle_category = None if not vehicle_type else get_or_none(VehicleCategory, id=vehicle_type)
vehicle.save()
def save_vendor_details(booking):
try:
vehicle = Vehicle.objects.get(
vehicle_number=compare_format(booking.lorry_number))
booking.truck_owner_name = None if not vehicle.owner else vehicle.owner.name.profile.name
booking.truck_owner_phone = None if not vehicle.owner else vehicle.owner.name.profile.phone
broker_vehicle = BrokerVehicle.objects.filter(vehicle=vehicle).last()
if broker_vehicle:
booking.truck_broker_owner_name = broker_vehicle.broker.name.profile.name
booking.truck_broker_owner_phone = broker_vehicle.broker.name.profile.phone
booking.driver_name = None if not vehicle.driver else vehicle.driver.name
booking.driver_phone = None if not vehicle.driver else vehicle.driver.phone
booking.driver_dl_number = None if not vehicle.driver else vehicle.driver.driving_licence_number
booking.driver_dl_validity = None if not vehicle.driver else vehicle.driver.driving_licence_validity
except Vehicle.DoesNotExist:
pass
booking.save()
def update_vehicle(request):
vehicle = Vehicle.objects.get(
id=int_or_none(request.POST.get('vehicle_id')))
vehicle.owner = get_or_none(Owner,
id=int_or_none(
request.POST.get('owner_id', None)))
vehicle.vehicle_number = compare_format(request.POST.get('vehicle_number'))
vehicle.rc_number = request.POST.get('rc_number')
vehicle.permit = request.POST.get('permit_number')
vehicle.permit_validity = django_date_format(
request.POST.get('permit_validity'))
vehicle.permit_type = request.POST.get('permit_type')
vehicle.vehicle_type = get_or_none(
VehicleCategory, id=int_or_none(request.POST.get('vehicle_category')))
vehicle.vehicle_capacity = to_int(
request.POST.get('exact_vehicle_capacity'))
vehicle.body_type = request.POST.get('vehicle_body_type')
vehicle.vehicle_model = request.POST.get('vehicle_model')
vehicle.chassis_number = request.POST.get('chassis_number')
vehicle.engine_number = request.POST.get('engine_number')
vehicle.insurer = request.POST.get('insurer')
vehicle.insurance_number = request.POST.get('insurance_number')
vehicle.insurance_validity = django_date_format(
request.POST.get('insurance_validity'))
vehicle.registration_year = None if not request.POST.get(
'registration_year') else django_date_format(
'01-Jan-' + request.POST.get('registration_year').strip())
vehicle.registration_validity = django_date_format(
request.POST.get('registration_validity'))
vehicle.fitness_certificate_number = request.POST.get(
'fitness_certificate_number')
vehicle.fitness_certificate_issued_on = django_date_format(
request.POST.get('fitness_certificate_issued_on'))
vehicle.fitness_certificate_validity_date = django_date_format(
request.POST.get('fitness_certificate_validity'))
vehicle.puc_certificate_number = request.POST.get('puc_certificate_number')
vehicle.puc_certificate_issued_on = django_date_format(
request.POST.get('puc_certificate_issued_on'))
vehicle.puc_certificate_validity_date = django_date_format(
request.POST.get('puc_certificate_validity'))
vehicle.gps_enabled = False if request.POST.get(
'gps_enable') == 'no' else True
vehicle.changed_by = request.user
vehicle.save()
return json_success_response("success")
def create(self, request, pk=None):
request.data['vehicle_number'] = compare_format(request.data['vehicle_number'])
if "created_by" not in request.data:
request.data["created_by"] = self.request.user.username
if "changed_by" not in request.data:
request.data["changed_by"] = self.request.user.username
if request.data.get('gps_enabled', None) == 'yes':
request.data['gps_enabled'] = True
else:
request.data['gps_enabled'] = False
if request.data.get('registration_year', None) and 'registration_year' in request.data:
request.data['registration_year'] = '01-Jan-{}'.format(request.data['registration_year'].strip())
vehicle_serializer = VehicleSerializer(data=request.data)
if vehicle_serializer.is_valid():
vehicle_serializer.save()
return success_response(status=status.HTTP_201_CREATED, msg="Vehicle Created", data=vehicle_serializer.data)
return error_response(status=status.HTTP_400_BAD_REQUEST, msg="Vehicle not Created",
data=vehicle_serializer.errors)
def update_secugps_device(df):
for i, rows in df.iterrows():
try:
veh = Vehicle.objects.get(
vehicle_number=compare_format(rows['vehicle_number']))
if SecuGPSDevice.objects.filter(
device_id__iexact=rows['deviceID']):
gps = SecuGPSDevice.objects.get(
device_id__iexact=rows['deviceID'])
gps.imei = rows['imei']
gps.latitude = rows['latitude']
gps.longitude = rows['longitude']
gps.address = rows['address']
gps.status = rows['status']
gps.vehicle_number = rows['vehicle_number']
gps.location_time = datetime.utcnow().now()
if veh.driver:
gps.driver_name = veh.driver.name
gps.driver_number = veh.driver.phone
gps.driver = veh.driver
gps.driving_licence_number = veh.driver.driving_licence_number
gps.save()
else:
secugps_device = SecuGPSDevice.objects.create(
device_id=rows['deviceID'],
imei=rows['imei'],
latitude=rows['latitude'],
longitude=rows['longitude'],
address=rows['address'],
status=rows['status'],
vehicle_number=rows['vehicle_number'],
location_time=datetime.utcnow().now(),
)
if veh.driver:
if veh.driver:
secugps_device.driver_name = veh.driver.name
secugps_device.driver_number = veh.driver.phone
secugps_device.driver = veh.driver
secugps_device.driving_licence_number = veh.driver.driving_licence_number
secugps_device.save()
except (Vehicle.DoesNotExist, Vehicle.MultipleObjectsReturned) as e:
pass
def shipment_gps_data(booking):
vehicle_number = compare_format(booking.lorry_number)
if GPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).exists():
# gps_data = GPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).last()
gps_data = get_gps_device_location_from_dynamo(vehicle_number)
elif TempoGoGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).exists():
gps_data = TempoGoGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).last()
elif SecuGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).exists():
gps_data = SecuGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).last()
elif MahindraGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).exists():
gps_data = MahindraGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).last()
elif TracknovateGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).exists():
gps_data = TracknovateGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).last()
elif WaytrackerGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).exists():
gps_data = WaytrackerGPSDevice.objects.filter(vehicle_number=vehicle_number).exclude(is_active=False).last()
else:
gps_data = None
bsm_location = BookingStatusesMappingLocation.objects.filter(
booking_status_mapping__manual_booking=booking).order_by('-id')[:1]
location_data = {}
if bsm_location or gps_data:
if not bsm_location or \
(gps_data and bsm_location and gps_data.location_time > bsm_location[
0].created_on):
location_data['latitude'] = gps_data.latitude
location_data['longitude'] = gps_data.longitude
location_data['driver_name'] = gps_data.driver_name
location_data['driver_number'] = gps_data.driver_number
location_data['location_time'] = gps_data.location_time
location_data['vehicle_number'] = gps_data.vehicle_number
else:
location_data['latitude'] = bsm_location[0].latitude
location_data['longitude'] = bsm_location[0].longitude
location_data['driver_name'] = booking.driver_name
location_data['driver_number'] = booking.driver_phone
location_data['location_time'] = bsm_location[0].created_on
location_data['vehicle_number'] = booking.vehicle_number
else:
location_data = None
return location_data
def owner_booking_data():
bookings = ManualBooking.objects.exclude(
Q(truck_owner_name=None) & Q(truck_owner_phone=None))
data = []
for booking in bookings.order_by('-shipment_date'):
try:
vehicle = Vehicle.objects.get(
vehicle_number=compare_format(booking.lorry_number))
if not vehicle.owner:
data.append([
booking.booking_id, booking.shipment_date,
booking.vehicle.vehicle_number, booking.truck_owner_name,
booking.truck_owner_phone
])
except Vehicle.DoesNotExist:
pass
df = pd.DataFrame(data=data,
columns=[
'Booking ID', 'Shipment Date', 'Vehicle Number',
'Owner', 'Phone'
])
df.to_excel('owner_without_vehicle.xlsx', index=False)
def vehicle_owner_update():
data = []
for booking in ManualBooking.objects.all():
try:
vehicle = Vehicle.objects.get(
vehicle_number=compare_format(booking.lorry_number))
if not vehicle.owner and booking.truck_owner_phone and Owner.objects.filter(
Q(name__profile__phone__icontains=booking.truck_owner_phone
)
| Q(name__profile__contact_person_phone__icontains=booking.
truck_owner_phone)).exists():
data.append([
vehicle.vehicle_number, '\n'.join([
'{}{}'.format(owner.get_name(), owner.get_phone())
for owner in Owner.objects.filter(
Q(name__profile__phone__icontains=booking.
truck_owner_phone)
| Q(name__profile__contact_person_phone__icontains=
booking.truck_owner_phone))
])
])
except Vehicle.DoesNotExist:
pass
print(data)
def parse_secugps_speed(html_data):
table = BeautifulSoup(html_data, 'lxml')
table = table.tbody
records = []
for tr in table.findAll("tr"):
trs = tr.findAll("td")
record = []
try:
record.append((compare_format(trs[0].text).replace('\n', '')))
log_time = trs[1].text
record.append(log_time[:6] + log_time[8:])
record.append(float((trs[2].text).split(' ')[0]))
location = ((trs[3].a['href'])[38:]).split(',')
record.append(float(location[0]))
record.append(float(location[1]))
records.append(record)
except IndexError:
pass
df = pd.DataFrame(data=records,
columns=[
'vehicle_number', 'datetime', 'speed', 'latitude',
'longitude'
])
return df
def update_secugps_device_log(df, device_id):
for i, rows in df.iterrows():
try:
veh = Vehicle.objects.get(
vehicle_number=compare_format(rows['vehicle_number']))
if SecuGPSDevice.objects.filter(device_id__iexact=device_id):
secugps_device_log = SecuGPSDeviceLog.objects.create(
device=SecuGPSDevice.objects.get(
device_id__iexact=device_id),
datetime=format_secugps_datetime(rows['datetime']),
vehicle_id=device_id,
latitude=rows['latitude'],
longitude=rows['longitude'],
speed=rows['latitude'],
vehicle_number=rows['vehicle_number'],
)
if veh.driver:
secugps_device_log.driver_name = veh.driver.name
secugps_device_log.driver_number = veh.driver.phone
secugps_device_log.driving_licence_number = veh.driver.driving_licence_number
secugps_device_log.save()
except (Vehicle.DoesNotExist, Vehicle.MultipleObjectsReturned,
DataError) as e:
raise
def create_broker_supplier():
df = pd.read_excel('../../data/brokers.xlsx')
df = df.fillna('')
for i, row in df.iterrows():
if not row['correct broker'] or row['id'] == row['correct broker']:
if not Supplier.objects.filter(user=User.objects.get(username=row['username'])).exists():
supplier = Supplier.objects.create(user=User.objects.get(username=row['username']),
created_by=User.objects.get(username='******'),
changed_by=User.objects.get(username='******'),
code=generate_supplier_code()
)
for vehicle in row['vehicles'].split('\n'):
vehicle = compare_format(vehicle)
if vehicle:
vehicle_instance = get_or_none(s_Vehicle, vehicle_number=vehicle)
if isinstance(vehicle_instance, s_Vehicle):
print(vehicle)
try:
SupplierVehicle.objects.create(vehicle=vehicle_instance, supplier=supplier,
ownership='B',
created_by=User.objects.get(username='******'),
changed_by=User.objects.get(username='******'))
except:
pass
def filter(self, qs, value):
vehicle_number = compare_format(value)
return super(VehicleFilter,
self).filter(qs, Lookup(vehicle_number, 'icontains'))
