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")