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 create_beneficiary_account(request):
account_number = request.POST.get('account_number')
bank = get_or_none(Bank, account_number=account_number)
if bank:
return render(request=request,
template_name='mobile/beneficiary_exists.html',
context={'bank': bank})
try:
account_document = request.FILES['account_document']
except MultiValueDictKeyError:
account_document = None
bank = Bank.objects.create(
bank=request.POST.get('bank_name'),
account_holder_name=request.POST.get('account_holder_name'),
beneficiary_code=request.POST.get('beneficiary_code'),
account_number=account_number,
transaction_type=request.POST.get('transaction_type'),
account_type=request.POST.get('account_type'),
ifsc=request.POST.get('ifsc'),
address=request.POST.get('address'),
city=request.POST.get('city'),
)
email_add_new_beneficiary(bank=bank)
if account_document:
filename = '%s.%s' % (account_number, get_ext(account_document.name))
s3util.save_to_s3_uploads_bank_doc(filename, account_document)
return json_success_response('success')
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 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 update_credit_note_customer_direct_advance(request, pk):
data = json.loads(request.body.decode('utf-8'))
data["changed_by"] = request.user.username
credit_note_customer_direct_advance = get_or_none(
CreditNoteCustomerDirectAdvance, id=pk)
if not isinstance(credit_note_customer_direct_advance,
CreditNoteCustomerDirectAdvance):
return json_400_incorrect_use()
if data['status'] == 'approved' and credit_note_customer_direct_advance.bookings.count(
) == 1:
data[
'adjusted_amount'] = credit_note_customer_direct_advance.credit_amount
data['status'] = 'adjusted'
data['adjusted_by'] = request.user.username
data['adjusted_on'] = datetime.now()
if Invoice.objects.filter(
bookings__in=credit_note_customer_direct_advance.bookings.all(
)).exists():
data['invoice'] = Invoice.objects.filter(
bookings__in=credit_note_customer_direct_advance.bookings.all(
)).last().id
credit_note_customer_direct_advance_serializer = CreditNoteCustomerDirectAdvanceSerializer(
instance=credit_note_customer_direct_advance, data=data, partial=True)
if credit_note_customer_direct_advance_serializer.is_valid():
credit_note_customer_direct_advance_serializer.save()
return json_success_response(msg='success')
return json_400_incorrect_use()
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 upload_daily_freight(request):
try:
save_to_s3_daily_freight(datetime.now().strftime('%Y%m%d%H%M') + '.xlsx',
request.FILES['daily_freight'])
except:
raise
try:
filename = S3Upload.objects.filter(folder__iexact='freight').latest('created_on').public_url()
df = pd.read_excel(filename)
for i, rows in df.iterrows():
route = map(str.strip, map(str, rows['Route'].split('-')))
if Route.objects.filter(Q(source__iexact=route[0]) & Q(destination__iexact=route[1])).exists():
route = Route.objects.get(Q(source__iexact=route[0]) & Q(destination__iexact=route[1]))
route.updated_on = datetime.now()
route.save()
if SubRoute.objects.filter(Q(loading_point__iexact=rows['Loading Point']) & Q(
unloading_point__iexact=rows['Unloading Point'])).exists():
SubRoute.objects.filter(Q(loading_point__iexact=rows['Loading Point']) & Q(
unloading_point__iexact=rows['Unloading Point'])).update(updated_on=datetime.now())
RouteFreight.objects.create(
route=SubRoute.objects.get(Q(loading_point__iexact=rows['Loading Point']) & Q(
unloading_point__iexact=rows['Unloading Point'])),
freight=rows['Freight (per ton)'],
material=rows['Material'],
datetime=datetime.now()
)
else:
RouteFreight.objects.create(
route=create_sub_route(route=route, loading_point=rows['Loading Point'],
unloading_point=rows['Unloading Point']),
freight=rows['Freight (per ton)'],
material=rows['Material'],
datetime=datetime.now()
)
else:
route = Route.objects.create(source=route[0], destination=route[1])
if SubRoute.objects.filter(Q(loading_point__iexact=rows['Loading Point']) & Q(
unloading_point__iexact=rows['Unloading Point'])).exists():
SubRoute.objects.filter(Q(loading_point__iexact=rows['Loading Point']) & Q(
unloading_point__iexact=rows['Unloading Point'])).update(updated_on=datetime.now())
RouteFreight.objects.create(
route=SubRoute.objects.get(Q(loading_point__iexact=rows['Loading Point']) & Q(
unloading_point__iexact=rows['Unloading Point'])),
freight=rows['Freight (per ton)'],
material=rows['Material'],
datetime=datetime.now()
)
else:
RouteFreight.objects.create(
route=create_sub_route(route=route, loading_point=rows['Loading Point'],
unloading_point=rows['Unloading Point']),
freight=rows['Freight (per ton)'],
material=rows['Material'],
datetime=datetime.now()
)
return json_success_response('Uploaded successfully')
except:
raise
def create_issue_credit_note_customer(request):
data = json.loads(request.body.decode('utf-8'))
credit_note_customer_serializer = CreditNoteCustomerSerializer(data=data)
# data["credit_note_number"] = generate_credit_note_customer_serial_number(data['customer'])
if credit_note_customer_serializer.is_valid():
credit_note_customer_serializer.save()
return json_success_response(
msg='Credit Note ID {} is generated'.format(
credit_note_customer_serializer.data['credit_note_number']))
return json_400_incorrect_use()
def contact_us_landing_page(request):
data = {
'name': request.POST.get('name'),
'phone': request.POST.get('phone'),
'email': request.POST.get('email'),
'message': request.POST.get('message'),
}
serializer = ContactUsLandingPageSerializer(data=data)
if serializer.is_valid():
serializer.save()
return json_success_response(msg="Ok")
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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 create_issue_debit_note_customer(request):
data = json.loads(request.body.decode('utf-8'))
data["changed_by"] = request.user.username
data["created_by"] = request.user.username
data["debit_note_number"] = generate_debit_note_customer_serial_number(
data['customer'])
debit_note_customer_serializer = DebitNoteCustomerSerializer(data=data)
if debit_note_customer_serializer.is_valid():
debit_note_customer_serializer.save()
return json_success_response(
msg='Debit Note ID {} is generated'.format(
debit_note_customer_serializer.data['debit_note_number']))
return json_400_incorrect_use()
def m_login(request):
username = request.POST.get('username', None)
password = request.POST.get('password', None)
print(username, password)
if not username or not password:
return json_400_incorrect_use()
user = authenticate(username=username, password=password)
if user is None:
return json_401_wrong_credentials()
if not user.is_active:
return json_401_inactive_user()
login(request, user)
return json_success_response(msg='success')
def register_owner(request):
username = "".join(re.split("[^a-zA-Z]*",
request.POST.get('owner_name')))[:12]
owner_name = request.POST.get('owner_name')
pan = request.POST.get('pan')
if User.objects.filter(username__iexact=username).exists():
username = random.randrange(999999999999, 99999999999999)
# if owner_name in Owner.objects.values_list('name__profile__name', flat=True):
# return json_error_response(msg='Owner {} already exists'.format(request.POST.get('owner_name')), status=409)
# if request.POST.get('pan') in Owner.objects.values_list('pan', flat=True):
# return json_error_response(msg='Pan {} already exists for {}'.format(owner_name, ''.join(
# Owner.objects.filter(pan=pan).values_list('name__profile__name', flat=True))), status=409)
#
# if Vehicle.objects.filter(id__in=request.POST.getlist('vehicle_id[]')).exclude(owner=None):
# print (Vehicle.objects.filter(id__in=request.POST.getlist('vehicle_id[]')).exclude(owner=None))
user = User.objects.create_user(username=str(username).lower(),
password='******')
Profile.objects.create(
user=user,
name=request.POST.get('owner_name'),
phone=request.POST.get('owner_phone', None),
contact_person_name=request.POST.get('contact_person_name'),
contact_person_phone=request.POST.get('contact_person_phone'),
alternate_phone=request.POST.get('alternate_number'),
email=request.POST.get('email'),
comment=request.POST.get('remarks'))
owner = Owner.objects.create(
name=user,
address=Address.objects.create(
line1=request.POST.get('owner_address'),
city=get_or_none(City, id=int_or_none(request.POST.get('city'))),
pin=request.POST.get('pin', None)),
route_temp=request.POST.get('route'),
pan=request.POST.get('pan'))
Broker.objects.create(name=user,
address=Address.objects.create(
line1=request.POST.get('owner_address'),
city=get_or_none(City,
id=int_or_none(
request.POST.get('city'))),
pin=request.POST.get('pin', None)),
route=request.POST.get('route'),
pan=request.POST.get('pan'))
try:
for vehicle in Vehicle.objects.filter(
id__in=request.POST.getlist('vehicle_id[]')):
vehicle.owner = owner
vehicle.save()
except ValueError:
pass
return json_success_response(msg="success")
def create_issue_credit_note_supplier(request):
data = json.loads(request.body.decode('utf-8'))
data["changed_by"] = request.user.username
data["created_by"] = request.user.username
data["credit_note_number"] = generate_credit_note_supplier_serial_number(
data['broker'])
credit_note_supplier_serializer = CreditNoteSupplierSerializer(data=data)
if credit_note_supplier_serializer.is_valid():
credit_note_supplier_serializer.save()
return json_success_response(
msg='Credit Note ID {} is generated'.format(
credit_note_supplier_serializer.data['credit_note_number']))
return json_400_incorrect_use()
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 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 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 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 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")
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 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 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_debit_note_supplier(request, pk):
data = json.loads(request.body.decode('utf-8'))
data["changed_by"] = request.user.username
debit_note_supplier = get_or_none(DebitNoteSupplier, id=pk)
if not isinstance(debit_note_supplier, DebitNoteSupplier):
return json_400_incorrect_use()
if data['status'] == 'approved' and debit_note_supplier.bookings.count(
) == 1:
data['adjusted_amount'] = debit_note_supplier.debit_amount
data['status'] = 'adjusted'
data['adjusted_by'] = request.user.username
data['adjusted_on'] = datetime.now()
if Invoice.objects.filter(
bookings__in=debit_note_supplier.bookings.all()).exists():
data['invoice'] = Invoice.objects.filter(
bookings__in=debit_note_supplier.bookings.all()).last().id
debit_note_supplier_serializer = DebitNoteSupplierSerializer(
instance=debit_note_supplier, data=data, partial=True)
if debit_note_supplier_serializer.is_valid():
debit_note_supplier_serializer.save()
return json_success_response(msg='success')
return json_400_incorrect_use()
def update_customer(request):
sme = get_or_none(Sme, id=int_or_none(request.POST.get('customer_id')))
# phone_status, msg = verify_profile_phone(username=sme.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)
create_update_profile(
user=sme.name,
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'))
create_update_address(address_id=sme.address_id,
line1=request.POST.get('company_address'),
city=get_or_none(City,
id=int_or_none(
request.POST.get('city'))),
pin=request.POST.get('pin'))
sme.customer_address = request.POST.get('company_address')
sme.aaho_office = get_or_none(AahoOffice,
id=request.POST.get('aaho_office'))
sme.city = get_or_none(City, id=int_or_none(request.POST.get('city')))
sme.pin = request.POST.get('pin')
sme.gstin = sme.gstin if not request.POST.get(
'gstin') else request.POST.get('gstin')
sme.is_gst_applicable = request.POST.get('is_gst_applicable')
sme.aaho_poc = get_or_none(Employee,
id=int_or_none(request.POST.get('aaho_poc')))
sme.credit_period = request.POST.get('credit_period', None)
sme.save()
return json_success_response(msg="success")
def pod_delivered_date_validation(request):
return json_success_response(msg="Valid")
def add_edit_vehicle(request):
data = request.data
vehicle_id = data.get('id', None)
if vehicle_id:
vehicle = get_or_none(Vehicle, id=int_or_none(vehicle_id))
if not vehicle:
return json_error_response(
'Vehicle with id=%s does not exist' % vehicle_id, 404)
else:
vehicle = Vehicle()
vehicle_number = data.get('vehicle_number', None)
if not vehicle_number and not vehicle_id:
return json_error_response('vehicle number required', 400)
owner_id = (data.get('owner', None) or {}).get('id', None)
owner = None
if owner_id:
owner = get_or_none(Owner, id=int_or_none(owner_id))
if not owner:
return json_error_response(
'Owner with id=%s does not exist' % owner_id, 404)
ac_id = (data.get('account', None) or {}).get('id', None)
account = None
if ac_id:
account = get_or_none(Bank, id=int_or_none(ac_id))
if not account:
return json_error_response(
'Bank account with id=%s does not exist' % ac_id, 404)
driver_id = (data.get('driver', None) or {}).get('id', None)
driver = None
if driver_id:
driver = get_or_none(Driver, id=int_or_none(driver_id))
if not driver:
return json_error_response(
'Driver with id=%s does not exist' % driver_id, 404)
current_city_id = data.get('current_city', None)
current_city = None
if current_city_id:
current_city = get_or_none(City, id=int_or_none(current_city_id))
if not current_city:
return json_error_response(
'City with id=%s does not exist' % current_city_id, 404)
vehicle_type_id = data.get('vehicle_type', None)
vehicle_type = None
has_vehicle_type_data = 'vehicle_type' in data
if vehicle_type_id:
vehicle_type = get_or_none(VehicleCategory,
id=int_or_none(vehicle_type_id))
if not vehicle_type:
return json_error_response(
'VehicleCategory with id=%s does not exist' % vehicle_type_id,
404)
else:
new_category_type = data.get('new_vehicle_category_type', None)
new_category_capacity = data.get('new_vehicle_category_capacity', None)
new_category_type = None if not new_category_type else new_category_type.strip(
)
new_category_capacity = None if not new_category_capacity else new_category_capacity.strip(
)
if new_category_type:
has_vehicle_type_data = True
vehicle_type, _ = VehicleCategory.objects.get_or_create(
vehicle_type=new_category_type, capacity=new_category_capacity)
if 'owner' in data:
vehicle.owner = owner
if 'driver' in data:
Vehicle.objects.filter(driver=driver).update(driver=None)
vehicle.driver = driver
if 'current_city' in data:
vehicle.current_city = current_city
if has_vehicle_type_data:
vehicle.vehicle_type = vehicle_type
normal_fields = [
'vehicle_number', 'vehicle_model', 'chassis_number', 'engine_number',
'sim_number', 'sim_operator', 'gps_enabled'
]
for field in normal_fields:
if field in data:
setattr(vehicle, field, data.get(field, None))
vehicle_status = data.get('status', None)
if vehicle_status:
if vehicle_status not in dict(VEHICLE_STATUS_CHOICES):
return json_response(
{
'status': 'error',
'msg': 'not a valid vehicle_status'
},
status=400)
vehicle.status = vehicle_status
if vehicle.driver_app_user:
vehicle.driver_app_user.vehicle_status = vehicle_status
vehicle.driver_app_user.save()
vehicle.save()
broker_vehicle, _created = BrokerVehicle.objects.get_or_create(
broker=request.broker, vehicle=vehicle)
if 'account' in data:
broker_vehicle.account_details = account
broker_vehicle.save()
if owner:
BrokerOwner.objects.get_or_create(broker=request.broker, owner=owner)
if driver:
BrokerDriver.objects.get_or_create(broker=request.broker,
driver=driver)
edited = False
doc_key = 'rc_doc'
if doc_key in data and data[doc_key].get('url'):
doc_id = data[doc_key].get('doc_id', None)
thumb = data[doc_key].get('thumb_url', None)
doc = Document.new(user=request.user,
bearer=vehicle,
field_name='registration_certificate',
document_type='REG',
document=data[doc_key]['url'],
doc_id=doc_id,
thumb=thumb)
doc.save()
registration_year = data[doc_key].get('manufacture_year', None)
validity = data[doc_key].get('validity', None)
vehicle.registration_certificate = doc
registration_year = None if not registration_year else registration_year.strip(
)
try:
registration_year = int(registration_year)
except ValueError:
registration_year = None
vehicle.registration_year = None if registration_year is None else datetime(
year=registration_year, month=1, day=1).date()
vehicle.registration_validity = None if not validity else parse_iso(
validity)
edited = True
doc_key = 'permit_doc'
if doc_key in data and data[doc_key].get('url'):
doc_id = data[doc_key].get('doc_id', None)
thumb = data[doc_key].get('thumb_url', None)
doc = Document.new(user=request.user,
bearer=vehicle,
field_name='permit_certificate',
document_type='PERM',
document=data[doc_key]['url'],
doc_id=doc_id,
thumb=thumb)
doc.save()
permit_type = data[doc_key].get('permit_type', None)
validity = data[doc_key].get('validity', None)
vehicle.permit_certificate = doc
vehicle.permit_type = permit_type
vehicle.permit_validity = None if not validity else parse_iso(validity)
vehicle.permit = doc_id
edited = True
doc_key = 'insurance_doc'
if doc_key in data and data[doc_key].get('url'):
doc_id = data[doc_key].get('doc_id', None)
thumb = data[doc_key].get('thumb_url', None)
doc = Document.new(user=request.user,
bearer=vehicle,
field_name='insurance_certificate',
document_type='INS',
document=data[doc_key]['url'],
doc_id=doc_id,
thumb=thumb)
doc.save()
insurer_name = data[doc_key].get('insurer_name', None)
validity = data[doc_key].get('validity', None)
vehicle.insurance_certificate = doc
vehicle.insurer = insurer_name
vehicle.insurance_validity = None if not validity else parse_iso(
validity)
vehicle.insurance_number = doc_id
edited = True
doc_key = 'fitness_doc'
if doc_key in data and data[doc_key].get('url'):
doc_id = data[doc_key].get('doc_id', None)
thumb = data[doc_key].get('thumb_url', None)
doc = Document.new(user=request.user,
bearer=vehicle,
field_name='fitness_certificate',
document_type='FIT',
document=data[doc_key]['url'],
doc_id=doc_id,
thumb=thumb)
doc.save()
validity = data[doc_key].get('validity', None)
vehicle.fitness_certificate = doc
vehicle.fitness_certificate_validity_date = None if not validity else parse_iso(
validity)
vehicle.fitness_certificate_number = doc_id
edited = True
doc_key = 'puc_doc'
if doc_key in data and data[doc_key].get('url'):
doc_id = data[doc_key].get('doc_id', None)
thumb = data[doc_key].get('thumb_url', None)
doc = Document.new(user=request.user,
bearer=vehicle,
field_name='puc_doc',
document_type='PUC',
document=data[doc_key]['url'],
doc_id=doc_id,
thumb=thumb)
doc.save()
validity = data[doc_key].get('validity', None)
vehicle.puc_certificate = doc
vehicle.puc_certificate_validity_date = None if not validity else parse_iso(
validity)
vehicle.puc_certificate_number = doc_id
edited = True
if edited:
vehicle.save()
doc_key = 'owner_pan_doc'
if doc_key in data and vehicle.owner and data[doc_key].get('url'):
doc_id = data[doc_key].get('doc_id', None)
thumb = data[doc_key].get('thumb_url', None)
doc = Document.new(user=request.user,
bearer=vehicle.owner,
field_name='taxation_details',
document_type='PAN',
document=data[doc_key]['url'],
doc_id=doc_id,
thumb=thumb)
doc.save()
taxation_details = vehicle.owner.taxation_details or TaxationID()
taxation_details.pan_doc = doc
taxation_details.pan = doc_id
taxation_details.save()
owner = vehicle.owner
owner.taxation_details = taxation_details
owner.save()
vehicle.owner = owner
doc_key = 'owner_dec_doc'
if doc_key in data and vehicle.owner and data[doc_key].get('url'):
doc_id = data[doc_key].get('doc_id', None)
thumb = data[doc_key].get('thumb_url', None)
doc = Document.new(user=request.user,
bearer=vehicle.owner,
field_name='declaration',
document_type='DEC',
document=data[doc_key]['url'],
doc_id=doc_id,
thumb=thumb)
doc.save()
validity = data[doc_key].get('validity', None)
owner = vehicle.owner
owner.declaration = doc.document
owner.declaration_doc = doc
owner.declaration_validity = None if not validity else parse_iso(
validity)
owner.save()
vehicle.owner = owner
doc_key = 'driver_dl_doc'
if doc_key in data and vehicle.driver and data[doc_key].get('url'):
doc_id = data[doc_key].get('doc_id', None)
thumb = data[doc_key].get('thumb_url', None)
doc = Document.new(user=request.user,
bearer=vehicle.driver,
field_name='driving_licence',
document_type='DL',
document=data[doc_key]['url'],
doc_id=doc_id,
thumb=thumb)
doc.save()
validity = data[doc_key].get('validity', None)
issue_loc = data[doc_key].get('issue_location', None)
driver = vehicle.driver
driver.driving_licence_number = doc_id
driver.driving_licence = doc
driver.driving_licence_location = issue_loc
driver.driving_licence_validity = None if not validity else parse_iso(
validity)
driver.save()
vehicle.driver = driver
return json_success_response('vehicle details %s' %
('edited' if vehicle_id else 'saved'),
data=vehicle.to_json())
def update_owner(request):
if request.POST.get('owner_name') in Owner.objects.exclude(
name__profile__name=request.POST.get('owner_name')).values_list(
'name__profile__name', flat=True):
return json_error_response(msg='Owner {} already exists'.format(
request.POST.get('owner_name')),
status=409)
owner = get_or_none(Owner, id=int_or_none(request.POST.get('owner_id')))
if owner:
profile = Profile.objects.get(user=owner.name)
profile.name = request.POST.get('owner_name')
profile.phone = request.POST.get('owner_phone')
profile.alternate_phone = request.POST.get('alternate_number')
profile.contact_person_name = request.POST.get('contact_person_name')
profile.contact_person_phone = request.POST.get('contact_person_phone')
profile.comment = request.POST.get('remarks')
profile.save()
if not owner.address:
owner.address = Address.objects.create(
line1=request.POST.get('owner_address'),
city=get_or_none(City,
id=int_or_none(request.POST.get('city'))),
pin=request.POST.get('pin'))
else:
address = Address.objects.get(id=owner.address.id)
address.line1 = request.POST.get('owner_address')
address.city = get_or_none(City, id=request.POST.get('city'))
address.pin = request.POST.get('pin')
address.save()
owner.temp_address = request.POST.get('owner_address')
owner.route_temp = request.POST.get('route')
owner.pan = request.POST.get('pan')
owner.save()
broker = get_or_none(Broker, name=owner.name)
if broker:
if broker.address:
broker.address = Address.objects.create(
line1=request.POST.get('owner_address'),
city=get_or_none(City,
id=int_or_none(request.POST.get('city'))),
pin=request.POST.get('pin'))
else:
address = get_or_none(
Address, id=None if not broker.address else broker.address.id)
if address:
address.line1 = request.POST.get('owner_address')
address.city = get_or_none(City,
id=int_or_none(
request.POST.get('city')))
address.pin = request.POST.get('pin')
address.save()
broker.pan = request.POST.get('pan')
broker.route = request.POST.get('route')
broker.city = get_or_none(City,
id=int_or_none(request.POST.get(
'city', None)))
broker.save()
else:
Broker.objects.create(
name=None if not owner.name else owner.name,
address=owner.address,
pan=owner.pan,
city=get_or_none(City,
id=int_or_none(request.POST.get('city', None))),
route=request.POST.get('route'))
for vehicle in Vehicle.objects.filter(
id__in=request.POST.getlist('vehicle_id[]')):
vehicle.owner = owner
vehicle.save()
broker = Broker.objects.get(name=owner.name)
try:
BrokerVehicle.objects.create(broker=broker, vehicle=vehicle)
except IntegrityError:
pass
return json_success_response(msg="success")
