def upload_driver_docs(request):
token = get_or_none(Token, key=request.POST.get('Authorization'))
if not isinstance(token, Token):
return HttpResponseRedirect('/login/')
try:
driver_id = int_or_none(request.POST.get('driver', None))
document_category = request.POST.get('document_category', None)
if not driver_id:
return json_error_response('driver_id id not provided', status=400)
if not document_category:
return json_error_response('document category id not provided', status=400)
driver = get_or_none(Driver, id=driver_id)
if not driver:
return json_error_response('Driver with id=%s not found' % driver, status=404)
if not request.FILES:
return json_error_response('no file to upload', status=400)
upload_file = request.FILES.get('file')
driver_files = create_driver_file(driver, document_category, upload_file, token.user)
return upload_json_response(request, data={'files': [serialize(driver_files)]})
except UnreadablePostError:
return HttpResponseRedirect('/upload/upload-driver-document-page/')
def update_pod(request):
driver = request.driverapp_user
can_upload_pod, reason, alloc_vehicle = get_can_upload_pod(driver)
if not can_upload_pod:
return json_error_response(reason, 400)
if not driver.vehicle_status == 'unloaded':
return json_error_response(
'Switch the status to unloaded before uploading POD', 400)
data = request.data
pod = data.get('pod', None)
pod_thumb = data.get('pod_thumb', None)
if not pod or not pod_thumb:
return json_error_response('pod file not sent', 400)
if alloc_vehicle.pod == pod:
return json_success_response('nothing to update')
alloc_vehicle.pod = pod
alloc_vehicle.pod_thumb = pod_thumb
alloc_vehicle.pod_date = timezone.now()
alloc_vehicle.save()
return json_response({
'status': 'success',
'msg': 'pod updated',
'pod_details': alloc_vehicle.pod_details()
})
def do_booking_vendor_request(request):
user = request.user
data = request.data
transaction_id = data.get('booking_id', None)
vendor_data = data.get('vendors', None)
if transaction_id is None or not vendor_data:
return json_400_incorrect_use()
try:
transaction = Transaction.objects.get(id=transaction_id)
except Transaction.DoesNotExist:
return json_error_response(
'no such transaction exits, id=' + transaction_id, 400)
vendors = []
for ven in vendor_data:
try:
vendors.append(UserVendor.objects.get(user=user, id=ven['id']))
except UserVendor.DoesNotExist:
return json_error_response('no such vendor exits, id=' + ven['id'],
400)
TransactionVendorRequest.objects.bulk_create([
TransactionVendorRequest(transaction=transaction, user=user, vendor=v)
for v in vendors
])
send_vendor_request_sms()
return json_response({
'status': 'success',
'msg': 'requests successfully sent to vendors'
})
def inner(request, *args, **kwargs):
if not request.user:
return json_error_response('no user present', 401)
if not request.user.is_authenticated:
return json_error_response('user is not authenticated', 401)
if not request.user.is_active:
return json_error_response('user authenticated but inactive', 401)
return func(request, *args, **kwargs)
def inner(request, *args, **kwargs):
if not request.user:
return json_error_response('no user present', 401)
if not request.user.is_authenticated:
return json_error_response('user is not authenticated', 401)
if not request.user.is_active:
return json_error_response('user authenticated but inactive', 401)
if not any(g.name == 'sme' for g in request.user.groups.all()):
return json_error_response('user not allowed to access this app',
401)
return func(request, *args, **kwargs)
def update_supplier(request):
supplier = get_or_none(Broker,
id=int_or_none(request.POST.get('supplier_id')))
phone_status, msg = verify_profile_phone(
username=supplier.name.username,
phone=request.POST.get('contact_person_number'),
alt_phone=request.POST.get('alternate_number'))
if phone_status:
return json_error_response(msg=msg, status=409)
email_status, msg = verify_profile_email(username=supplier.name.username,
email=request.POST.get('email'),
alt_email=None)
if email_status:
return json_error_response(msg=msg, status=409)
if request.POST.get('pan') and Broker.objects.exclude(
name=supplier.name).filter(pan=request.POST.get('pan')).exists():
return json_error_response("PAN Already exists", status=409)
profile = Profile.objects.get(user=supplier.name)
profile.name = request.POST.get('supplier_name')
profile.contact_person_name = request.POST.get('contact_person_name')
profile.phone = request.POST.get('phone')
profile.alternate_phone = request.POST.get('alt_phone')
profile.email = request.POST.get('email')
profile.comment = request.POST.get('remarks')
profile.save()
create_update_profile(
user=supplier.name,
name=request.POST.get('supplier_name'),
contact_person=request.POST.get('contact_person_name'),
contact_person_phone=request.POST.get('contact_person_number'),
phone=request.POST.get('contact_person_number'),
alternate_phone=request.POST.get('alternate_number'),
email=request.POST.get('email'),
remarks=request.POST.get('remarks'))
supplier.pan = request.POST.get('pan')
supplier.route = request.POST.get('route')
supplier.city = get_or_none(City,
id=int_or_none(
request.POST.get('supplier_city')))
supplier.aaho_office = get_or_none(AahoOffice,
id=request.POST.get('aaho_office'))
supplier.destination_state.clear()
dest_states = request.POST.getlist('destination_states[]')
if dest_states:
if 'select_all' in dest_states:
dest_states = State.objects.values_list('id', flat=True)
for dest_state in dest_states:
supplier.destination_state.add(dest_state)
supplier.save()
return json_success_response("success")
def delete_invoice_receipt(request, pk):
invoice_receipt_id = pk
if not invoice_receipt_id:
return json_error_response('cheque_file_id not provided', status=400)
invoice_receipt = get_or_none(InvoiceReceiptFile, id=invoice_receipt_id)
if not invoice_receipt:
return json_error_response('ChequeFile with id=%s not found' % invoice_receipt_id, status=404)
invoice_receipt.s3_upload.delete_from_s3()
invoice_receipt.delete()
return upload_json_response(request, True)
def register_customer(request):
if request.POST.get('email_id') and Profile.objects.filter(
email__iexact=request.POST.get('email_id')).exists():
return json_error_response('Email ID Already Exists', status=409)
elif Profile.objects.filter(
name__iexact=request.POST.get('company_name')).exists():
return json_error_response('Company Already Registered', status=409)
# elif Profile.objects.filter(phone__iexact=request.POST.get('contact_person_number')).exists():
# return json_error_response('Phone Already Exists', status=409)
elif Sme.objects.filter(
company_code__iexact=request.POST.get('company_code')).exists():
return json_error_response('Company Code Already Exists', status=409)
else:
username = "".join(
re.split("[^a-zA-Z]*", request.POST.get('company_name')))[:12]
if User.objects.filter(username__iexact=username).exists():
username = random.randrange(999999999999, 99999999999999)
user = User.objects.create_user(username=str(username).lower(),
password='******')
create_update_profile(
user=user,
name=request.POST.get('company_name'),
contact_person=request.POST.get('contact_person_name'),
contact_person_phone=request.POST.get('contact_person_number'),
phone=request.POST.get('contact_person_number'),
alternate_phone=request.POST.get('alternate_number'),
email=request.POST.get('email_id'),
remarks=request.POST.get('remarks'))
Sme.objects.create(
name=user,
company_code=request.POST.get('company_code'),
aaho_office=get_or_none(AahoOffice,
id=request.POST.get('aaho_office')),
gstin=request.POST.get('gstin', None),
aaho_poc=get_or_none(Employee,
id=int_or_none(request.POST.get('aaho_poc'))),
credit_period=request.POST.get('credit_period', None),
address=create_update_address(
line1=request.POST.get('company_address'),
city=get_or_none(City,
id=int_or_none(request.POST.get('city'))),
pin=request.POST.get('pin')),
is_gst_applicable='no'
if request.POST.get('is_gst_applicable') == 'n' else 'yes',
customer_address=request.POST.get('company_address'),
city=get_or_none(City, id=int_or_none(request.POST.get('city'))),
pin=request.POST.get('pin'),
created_by=request.user)
return json_success_response('SME Successfully Registered')
def delete_pod(request, pk):
pod_file_id = pk
if not pod_file_id:
return json_error_response('pod_file_id not provided', status=400)
pod_file = get_or_none(PODFile, id=pod_file_id)
if not pod_file:
return json_error_response('PODFile with id=%s not found' % pod_file_id, status=404)
pod_file.s3_upload.delete_from_s3()
pod_file.delete()
return upload_json_response(request, True)
def delete_cheque(request, pk):
cheque_file_id = pk
if not cheque_file_id:
return json_error_response('cheque_file_id not provided', status=400)
cheque_file = get_or_none(ChequeFile, id=cheque_file_id)
if not cheque_file:
return json_error_response('ChequeFile with id=%s not found' % cheque_file_id, status=404)
cheque_file.s3_upload.delete_from_s3()
cheque_file.delete()
return upload_json_response(request, True)
def delete_driver(request, pk):
driver_file_id = pk
if not driver_file_id:
return json_error_response('driver_file_id not provided', status=400)
driver_file = get_or_none(DriverFile, id=driver_file_id)
if not driver_file:
return json_error_response('DriverFile with id=%s not found' % driver_file_id, status=404)
driver_file.s3_upload.delete_from_s3()
driver_file.delete()
return upload_json_response(request, True)
def delete_supplier(request, pk):
supplier_file_id = pk
if not supplier_file_id:
return json_error_response('supplier_file_id not provided', status=400)
supplier_file = get_or_none(OwnerFile, id=supplier_file_id)
if not supplier_file:
return json_error_response('SupplierFile with id=%s not found' % supplier_file_id, status=404)
supplier_file.s3_upload.delete_from_s3()
supplier_file.delete()
return upload_json_response(request, True)
def delete_vehicle(request, pk):
vehicle_file_id = pk
if not vehicle_file_id:
return json_error_response('vehicle_file_id not provided', status=400)
vehicle_file = get_or_none(VehicleFile, id=vehicle_file_id)
if not vehicle_file:
return json_error_response('VehicleFile with id=%s not found' % vehicle_file_id, status=404)
vehicle_file.s3_upload.delete_from_s3()
vehicle_file.delete()
return upload_json_response(request, True)
def delete_weighing_slip(request, pk):
weighing_slip_id = pk
if not weighing_slip_id:
return json_error_response('weighing_slip_id not provided', status=400)
weighing_slip = get_or_none(WeighingSlip, id=weighing_slip_id)
if not weighing_slip:
return json_error_response('weighing_slip_id with id=%s not found' % weighing_slip_id, status=404)
weighing_slip.s3_upload.delete_from_s3()
weighing_slip.delete()
return upload_json_response(request, True)
def verify_otp(request):
data = request.data
otp = data.get('otp', None)
driverapp_user = request.driverapp_user
phone = driverapp_user.driver_number
if not phone or not otp:
return json_400_incorrect_use()
verified, msg = OTP.verify(phone, otp)
if not verified:
return json_error_response('OTP not valid: ' + msg, status=401)
driverapp_user.number_verified = True
try:
driver_model = Driver.objects.get(phone=phone)
except Driver.DoesNotExist:
try:
driver_model = Driver.objects.filter(alt_phone=phone)[0]
except IndexError:
driver_model = None
driverapp_user.driver = driver_model
driverapp_user.save()
set_vehicle_driverapp_user(driverapp_user)
if driverapp_user.number_verified:
Vehicle.objects.filter(driver_app_user=driverapp_user).update(
status=driverapp_user.vehicle_status)
return json_success_response('number verified')
def wrong_method_response(request, method_allowed):
msg = 'method=%s not supported, only %s is allowed' % (request.method,
method_allowed)
if request.is_ajax():
return json_error_response(msg, status=405)
else:
return HttpResponse(msg, status=405)
def send_otp(request):
driver = request.driverapp_user
if driver.driver_number:
send_otp_sms(driver.driver_number)
return json_success_response("otp sent")
else:
return json_error_response("no phone number to send otp to", 400)
def register_supplier(request):
if request.POST.get('email_id') and Profile.objects.filter(
email__iexact=request.POST.get('email_id')).exists():
return json_error_response('Email ID Already Exists', status=409)
elif Profile.objects.filter(
name__iexact=request.POST.get('supplier_name')).exists():
return json_error_response('Supplier Already Registered', status=409)
elif Profile.objects.filter(
phone=request.POST.get('contact_person_number')).exists():
return json_error_response('Phone Already Exists', status=409)
elif request.POST.get('pan') and TaxationID.objects.filter(
pan__iexact=request.POST.get('pan')).exists():
return json_error_response('PAN Already Exists', status=409)
else:
username = "".join(
re.split("[^a-zA-Z]*", request.POST.get('supplier_name')))[:12]
if User.objects.filter(username__iexact=username).exists():
username = random.randrange(999999999999, 99999999999999)
user = User.objects.create_user(username=str(username).lower(),
password='******')
create_update_profile(
user=user,
name=request.POST.get('supplier_name'),
contact_person=request.POST.get('contact_person_name'),
contact_person_phone=request.POST.get('contact_person_number'),
phone=request.POST.get('contact_person_number'),
alternate_phone=request.POST.get('alternate_number'),
email=request.POST.get('email_id'),
remarks=request.POST.get('remarks'))
instance = Broker.objects.create(
name=user,
city=get_or_none(City,
id=int_or_none(
request.POST.get('supplier_city'))),
route=request.POST.get('route'),
taxation_details=None if not request.POST.get('pan') else
TaxationID.objects.create(pan=request.POST.get('pan')),
aaho_office=get_or_none(AahoOffice,
id=request.POST.get('aaho_office')))
dest_states = request.POST.getlist('destination_states[]')
if dest_states:
if 'select_all' in dest_states:
dest_states = State.objects.values_list('id', flat=True)
for dest_state in dest_states:
instance.destination_state.add(dest_state)
return json_success_response('Supplier Successfully Registered')
def do_booking_save(request):
user = request.user
data = request.data
pickup_data = data.get('pickups', None)
drop_data = data.get('drops', None)
vehicle_data = data.get('vehicles', None)
contact_person = data.get('contact_person', None)
contact_number = data.get('contact_number', None)
shipment_datetime = data.get('shipment_datetime', None)
material = data.get('material', None)
rate = data.get('rate', None)
if not (pickup_data and drop_data and vehicle_data and contact_number
and contact_person and shipment_datetime):
return json_error_response('insufficient data to process booking', 400)
trans = create_new_transaction(user, contact_person, contact_number,
shipment_datetime, material, rate)
for p in pickup_data:
create_stop_point('loading', trans, p['address'], p['city']['id'])
for d in drop_data:
create_stop_point('unloading', trans, d['address'], d['city']['id'])
for vehicle in vehicle_data:
if 'id' in vehicle:
v_cat = VehicleCategory.objects.get(id=vehicle['id'])
VehicleRequest.objects.create(transaction=trans,
vehicle_category=v_cat,
vehicle_type=v_cat.vehicle_type,
vehicle_capacity=v_cat.capacity,
quantity=vehicle['count'])
else:
VehicleRequest.objects.create(transaction=trans,
vehicle_type=vehicle['name'],
vehicle_capacity=vehicle['capacity'],
quantity=vehicle['count'])
send_booking_email(user, pickup_data, drop_data, contact_number,
shipment_datetime, material)
send_booking_sms(user, pickup_data, drop_data, contact_number,
shipment_datetime)
city_scores, address_scores = get_ranking_results(request.user.id)
vendor_data = list(
UserVendor.objects.filter(user=request.user).values(
'id', 'name', 'phone'))
return json_response({
'status': 'success',
'msg': 'booked',
'booking_id': trans.id,
'city_scores': city_scores,
'address_scores': address_scores,
'vendors': vendor_data
})
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 inner(request, *args, **kwargs):
if not request.user:
return json_error_response('no user present', 401)
if not request.user.is_authenticated:
return json_error_response('user is not authenticated', 401)
if not request.user.is_active:
return json_error_response('user authenticated but inactive', 401)
if not any(g.name == 'fms' or g.name == 'sme' for g in request.user.groups.all()):
return json_error_response('user not allowed to access this app', 401)
broker, owner = get_broker_and_owner(request.user)
if not broker:
return json_error_response('user has no supplier or owner entry present', 401)
request.broker = broker;
request.owner = owner
return func(request, *args, **kwargs)
def resubmit_rejected_pod(request):
resubmission_remark = request.POST.get('resubmission_remark')
booking_id = request.POST.get('booking_id')
resubmitted_pod = request.POST.getlist('resubmitted_pod')
if not resubmission_remark:
return json_error_response(msg="Remarks is mandatory", status=400)
if not booking_id:
return json_error_response(msg="Booking id is required", status=400)
booking = get_or_none(ManualBooking, booking_id=booking_id)
if not isinstance(booking, ManualBooking):
return json_error_response(msg="BAD request", status=400)
if not PODFile.objects.filter(booking=booking).exists():
return json_error_response("BAD Request", status=400)
PODFile.objects.filter(id__in=resubmitted_pod).update(verified=False,
is_valid=False)
PODFile.objects.filter(booking=booking).exclude(
id__in=resubmitted_pod).update(verified=True, is_valid=False)
booking.pod_status = 'unverified'
booking.save()
return json_success_response(msg="success")
def update_booking_pod_data(request):
approve_type = request.POST.get('accept_choice')
if approve_type == 'accept':
booking = ManualBooking.objects.get(id=request.POST.get('booking_id'))
booking.supplier_charged_weight = to_float(
request.POST.get('supplier_weight'))
booking.charged_weight = to_float(request.POST.get('party_weight'))
booking.loaded_weight = to_float(request.POST.get('loaded_weight'))
booking.delivered_weight = to_float(
request.POST.get('delivered_weight'))
booking.pod_date = datetime.now()
booking.delivery_datetime = django_date_format(
request.POST.get('delivery_datetime'))
for pod in PODFile.objects.filter(booking=booking).exclude(
verified=True):
pod.is_valid = True
pod.verified = True
pod.verified_by = request.user
pod.verified_datetime = datetime.now()
pod.save()
S3Upload.objects.filter(id=pod.s3_upload_id).update(is_valid=True,
verified=True)
# if verify_pod(booking=booking):
booking.pod_status = 'completed'
booking.save()
return json_success_response(
msg='POD for booking ID {} is Accepted'.format(booking.booking_id))
elif approve_type == 'reject':
booking = ManualBooking.objects.get(id=request.POST.get('booking_id'))
booking.pod_status = 'rejected'
booking.save()
for lr in booking.lr_numbers.all():
RejectedPOD.objects.create(
booking=booking,
lr=lr,
remarks=request.POST.get('rejection_remark'),
rejected_by=request.user)
if not booking.lr_numbers.exists():
RejectedPOD.objects.create(
booking=booking,
remarks=request.POST.get('rejection_remark'),
rejected_by=request.user)
for pod in PODFile.objects.filter(booking=booking).exclude(
verified=True):
pod.is_valid = False
pod.verified = True
pod.verified_by = request.user
pod.verified_datetime = datetime.now()
pod.save()
S3Upload.objects.filter(id=pod.s3_upload_id).update(is_valid=False,
verified=True)
return json_success_response(
msg='POD for booking ID {} is rejected'.format(booking.booking_id))
return json_error_response(msg='fail', status=404)
def vehicle_trip_data(request):
data = request.data
vehicle_id = int_or_none(data.get('vehicleId', None))
if vehicle_id:
vehicle = get_or_none(Vehicle, id=vehicle_id)
if not vehicle:
return json_error_response(
'Vehicle with id=%s does not exist' % vehicle_id, 404)
else:
broker_vehicle_ids = BrokerVehicle.objects.filter(
vehicle=vehicle).values_list('vehicle_id', flat=True)
allocated_vehicles_data = VehicleAllocated.objects.filter(
vehicle_number_id__in=broker_vehicle_ids).values(
'transaction_id', 'total_out_ward_amount',
'total_amount_to_owner', 'transaction__shipment_datetime',
'source_city', 'destination_city', 'transaction_id',
'material', 'transaction__total_vehicle_requested',
'transaction__transaction_status',
'transaction__transaction_id',
'vehicle_number__vehicle_number', 'lr_number')
transaction_data = [{
'id':
v['transaction_id'],
'transaction_id':
v['transaction__transaction_id'],
'status':
v['transaction__transaction_status'],
'source_city':
v['source_city'],
'destination_city':
v['destination_city'],
'paid':
str(int(v['total_out_ward_amount'])),
'amount':
str(int(v['total_amount_to_owner'])),
'balance':
str(
int(v['total_amount_to_owner'] -
v['total_out_ward_amount'])),
'total_vehicle_requested':
v['transaction__total_vehicle_requested'],
'vehicle_number':
display_format(v['vehicle_number__vehicle_number']),
'lr_number':
v['lr_number'],
'shipment_date':
v['transaction__shipment_datetime'].strftime('%d-%b-%Y')
} for v in allocated_vehicles_data]
return json_response({
'status': 'success',
'data': transaction_data
})
else:
vehicle = Vehicle()
def no_auth_response(request, msg):
error_msg = 'Permission Denied: %s' % msg
if request.is_ajax():
return json_error_response(error_msg, status=401)
# is not ajax
if request.method == 'GET':
login_url = '/?' + query_string({
'from': request.get_full_path(),
'error': error_msg
})
return HttpResponseRedirect(redirect_to=login_url)
else:
raise PermissionDenied
def upload_pod(request):
token = get_or_none(Token, key=request.POST.get('Authorization'))
if not isinstance(token, Token):
return HttpResponseRedirect('/login/')
try:
lr_number_id = request.POST.get('lr_number', None)
if not lr_number_id:
return json_error_response('lr_number id not provided', status=400)
if str(lr_number_id).startswith('BROKER') or str(lr_number_id).startswith('AB'):
booking = get_or_none(ManualBooking, booking_id=lr_number_id)
lr_obj = None
else:
lr_obj = get_or_none(LrNumber, id=lr_number_id)
booking = None if not isinstance(lr_obj, LrNumber) else lr_obj.booking
if not (isinstance(lr_obj, LrNumber) or isinstance(booking, ManualBooking)):
return json_error_response('LrNumber with id=%s not found' % lr_number_id, status=404)
if not request.FILES:
return json_error_response('no file to upload', status=400)
upload_file = request.FILES.get('file')
pod_file = create_pod_file(lr_number=lr_obj, upload_file=upload_file, user=token.user, booking=booking)
booking_unloaded = check_booking_status(booking, 'unloaded')
if not booking_unloaded:
create_new_booking_status(booking, 'unloaded', User.objects.get(username='******'))
else:
update_booking_status(booking, 'unloaded', 'in_progress', User.objects.get(username='******'))
booking_pod_uploaded = check_booking_status(booking, 'pod_uploaded')
if not booking_pod_uploaded:
create_new_booking_status(booking, 'pod_uploaded', token.user)
else:
update_booking_status(booking, 'pod_uploaded', 'in_progress', token.user)
return upload_json_response(request, data={'files': [serialize(pod_file)]})
except UnreadablePostError:
return HttpResponseRedirect('/upload/pod/')
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 upload_weighing_slip_docs(request):
token = get_or_none(Token, key=request.POST.get('Authorization'))
if not isinstance(token, Token):
return HttpResponseRedirect('/login/')
try:
mb_id = int_or_none(request.POST.get('mb_id', None))
if not mb_id:
return json_error_response('mb_id id not provided', status=400)
booking = get_or_none(ManualBooking, id=mb_id)
if not isinstance(booking, ManualBooking):
return json_error_response('Manual Booking with id=%s not found' % mb_id, status=404)
if not request.FILES:
return json_error_response('no file to upload', status=400)
upload_file = request.FILES.get('file')
weighing_slip_files = create_weighing_slip_file(booking, upload_file, token.user)
return upload_json_response(request, data={'files': [serialize(weighing_slip_files)]})
except UnreadablePostError:
return HttpResponseRedirect('/upload/upload-vehicle-document-page/')
def register_driver(request):
if Driver.objects.filter(
phone=request.POST.get('driver_phone_number')).exists():
return json_error_response('Driver Already Exists', status=409)
else:
Driver.objects.create(
name=request.POST.get('driver_name'),
phone=request.POST.get('driver_phone_number'),
alt_phone=request.POST.get('driver_alt_phone_number1'),
alt_phone2=request.POST.get('driver_alt_phone_number2'),
driving_licence_number=request.POST.get('dl_number'),
driving_licence_validity=django_date_format(
request.POST.get('dl_validity')),
route=request.POST.get('route'),
driving_licence_location=request.POST.get('driver_city'))
return json_success_response('Driver Successfully Registered')
def update_driver_details(request):
if Driver.objects.filter(
phone=request.POST.get('driver_phone_number')).exclude(
id=int_or_none(request.POST.get('driver_id'))).exists():
return json_error_response("Phone Already Exists", status=409)
driver = get_or_none(Driver, id=int_or_none(request.POST.get('driver_id')))
if driver:
driver.name = request.POST.get('driver_name')
driver.phone = request.POST.get('driver_phone_number')
driver.alt_phone = request.POST.get('driver_alt_phone_number1')
driver.alt_phone2 = request.POST.get('driver_alt_phone_number2')
driver.driving_licence_number = request.POST.get('dl_number')
driver.driving_licence_validity = django_date_format(
request.POST.get('dl_validity'))
driver.route = request.POST.get('route')
driver.save()
return json_success_response("Updated success")
