def app_version_add(request):
form = MobileAppVersionsForm(request.data)
if not form.is_valid():
return {'status': 'failure', 'msg': 'Pls enter all * fields'}
app_platform = request.data.get('app_platform')
app_name = request.data.get('app_name')
app_version = request.data.get('app_version')
comment = request.data.get('comment')
objects = {
'app_platform': app_platform,
'app_name': app_name,
'app_version': app_version,
'comment': comment
}
try:
MobileAppVersions.objects.create(**objects)
except IntegrityError:
return json_response({
'status': 'failure',
'msg': 'MobileAppVersions could not be created'
})
return json_response({
'status': 'success',
'msg': 'MobileAppVersions successfully submitted'
})
def do_delete_vendor(request):
vendor_id = request.data.get('id', None)
if vendor_id is None:
return json_400_incorrect_use()
try:
vendor = UserVendor.objects.get(id=vendor_id)
except UserVendor.DoesNotExist:
return json_400_incorrect_use()
if not vendor.user == request.user:
return json_response(
{
'status': 'error',
'msg': 'user does not own the object'
},
status=403)
UserVendor.objects.filter(id=vendor_id).delete()
vendor_data = list(
UserVendor.objects.filter(user=request.user).order_by('id').values(
'id', 'name', 'phone'))
return json_response({
'status': 'success',
'msg': 'vendor added',
'vendors': vendor_data
})
def register(request):
data = request.data
device_id = data.get('device_id', None)
if not device_id:
return json_response(
{
'status': 'error',
'msg': 'cannot register without device id'
},
status=400)
driver_name = data.get('driver_name', None)
driver_number = data.get('driver_number', None)
vehicle_number = data.get('vehicle_number', None)
vehicle_type = data.get('vehicle_type', None)
driver_number = None if not driver_number else driver_number.strip()
created = False
try:
driver_app_user = DriverAppUser.objects.get(device_id=device_id)
except DriverAppUser.DoesNotExist:
driver_app_user = DriverAppUser(device_id=device_id)
created = True
if driver_number and driver_number != driver_app_user.driver_number:
driver_app_user.number_verified = False
driver = get_or_none(Driver, phone=driver_number)
driver_app_user.driver_name = driver_name
driver_app_user.driver_number = driver_number
driver_app_user.vehicle_number = vehicle_number
driver_app_user.vehicle_type = vehicle_type
driver_app_user.driver = driver
driver_app_user.save()
vehicle = set_vehicle_driverapp_user(driver_app_user)
data = {
'imei': data.get('device_id', None),
'device_id': data.get('device_id', None),
'driver_name': driver_name,
'driver_number': driver_number,
'vehicle_number': vehicle_number,
'vehicle': vehicle.id if isinstance(vehicle, Vehicle) else None,
'driver': driver.id if isinstance(driver, Driver) else None,
'vehicle_type': vehicle_type,
'device_provider': 7
}
gps_device_serializer = GPSDeviceSerializer(data=data)
if gps_device_serializer.is_valid():
gps_device_serializer.save()
print(gps_device_serializer.errors)
data = merge(
{
'status': 'success',
'msg': 'registered' if created else 'registration updated',
'auth_token': driver_app_user.auth_token,
}, driver_app_data(driver_app_user))
return json_response(data)
def change_password(request):
current_password = request.data.get('current_password', None)
new_password = request.data.get('new_password', None)
if not current_password or not new_password:
return json_400_incorrect_use()
if not request.user.check_password(current_password):
return json_response({
'status': 'error',
'msg': 'incorrect password'
},
status=403)
if len(new_password) < 8:
return json_response(
{
'status': 'error',
'msg': 'password should be minimum 8 characters long'
},
status=400)
request.user.set_password(new_password)
request.user.save()
return json_response({'status': 'success', 'msg': 'password changed'})
def api_logout(request):
if request.user and request.user.is_authenticated:
logout(request)
return json_response({'status': 'success', 'msg': 'logout successful'})
else:
return json_response({
'status': 'success',
'msg': 'already logged out'
})
def create_notification_device(request):
# data = json.loads(request.body)
# token = data['token']
# device_id = data['device_id']
token = request.data.get('token')
device_id = request.data.get('device_id')
app = request.data.get('app')
if not token:
return json_response({
'status': 'failure',
'msg': 'Pls enter all * fields'
})
if not device_id:
return json_response({
'status': 'failure',
'msg': 'Pls enter all * fields'
})
if not app:
return json_response({
'status': 'failure',
'msg': 'Pls enter all * fields'
})
# form = MobileDeviceForm(request.data)
# if not form.is_valid():
# return json_response({'status': 'failure', 'msg': 'Pls enter all * fields'})
try:
if not MobileDevice.objects.filter(device_id=device_id,
user=request.user).exists():
print('creating mobile device entry')
MobileDevice.objects.create(user=request.user,
app=app,
active=True,
token=token,
device_id=device_id,
changed_by=request.user)
else:
print('updating mobile device entry')
MobileDevice.objects.filter(device_id=device_id,
user=request.user).update(
# user=request.user,
token=token,
changed_by=request.user,
updated_on=datetime.datetime.now())
return json_response({
'status': 'success',
'msg': 'Token Successfully saved'
})
except IntegrityError:
return json_response({
'status': 'failure',
'msg': 'Token could not be saved'
})
def get_all_app_versions(request):
appversions = MobileAppVersions.objects.all().exclude(deleted=True)
if not appversions:
return json_response({
'status': 'failure',
'msg': 'No app versions found',
'data': {}
})
return json_response({
'status': 'success',
'msg': 'app version data',
'data': get_appversion_data(appversions)
})
def get_all_mobile_devices(request):
mobiledevices = MobileDevice.objects.all().exclude(deleted=True)
if not mobiledevices:
return json_response({
'status': 'failure',
'msg': 'No devices found',
'data': {}
})
return json_response({
'status': 'success',
'msg': 'mobile device data',
'data': get_mobiledevice_data(mobiledevices)
})
def get_all_requirements(request):
requirements = Requirement.objects.all().exclude(deleted=True)
if not requirements:
return json_response({
'status': 'failure',
'msg': 'No requirements found',
'data': {}
})
return json_response({
'status': 'success',
'msg': 'requirements data',
'data': get_requirement_data(requirements)
})
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 delete_requirement(request):
form = RequirementGetForm(request.data)
if not form.is_valid():
return json_response({'status': 'failure', 'msg': 'Incorrect values'})
requirement = get_or_none(Requirement,
id=request.data.get('requirement_id'))
if not requirement or requirement.deleted:
return json_response({
'status': 'failure',
'msg': 'Requirement not found',
'data': {}
})
requirement.deleted = True
requirement.deleted_on = timezone.now()
requirement.save(update_fields=['deleted', 'deleted_on'])
return json_response({'status': 'success', 'msg': 'requirement deleted'})
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 team_customer_booking_data(request):
print(request.data)
customer = Sme.objects.get(name=request.user)
# broker = Broker.objects.get(name=User.objects.get(username=request.user.username))
bookings = ManualBooking.objects.filter(company=customer,
shipment_date__gte=datetime(2017, 12, 1).date()).exclude(
booking_status__icontains='cancelled').order_by('-shipment_date')
return json_response({'status': 'success', 'data': supplier_booking_data(bookings=bookings)})
def get_requirement(request):
form = RequirementGetForm(request.data)
if not form.is_valid():
return json_response({'status': 'failure', 'msg': 'Incorrect values'})
req = Requirement.objects.filter(
id=request.data.get('requirement_id')).exclude(deleted=True)
if not req:
return json_response({
'status': 'failure',
'msg': 'Requirement not found',
'data': {}
})
return json_response({
'status': 'success',
'msg': 'requirement data',
'data': get_requirement_data(req)
})
def add_new_requirement(request):
objects = parse_requirement_fields(request)
if objects['status'] == 'failure':
return json_response({'status': 'failure', 'msg': objects['msg']})
objects.pop('status', None)
try:
Requirement.objects.create(**objects)
except IntegrityError:
return json_response({
'status': 'failure',
'msg': 'Requirement could not be created'
})
return json_response({
'status': 'success',
'msg': 'Requirement successfully submitted'
})
def update_requirement(request):
if not request.data.get('requirement_id'):
return json_response({
'status': 'failure',
'msg': 'Requirement Id is not passed'
})
requirement = get_or_none(Requirement,
id=request.data.get('requirement_id'))
if not requirement or requirement.deleted:
return json_response({
'status': 'failure',
'msg': 'Requirement not found',
'data': {}
})
objects = parse_requirement_fields(request)
if objects['status'] == 'failure':
return json_response({'status': 'failure', 'msg': objects['msg']})
requirement.client = objects['client']
requirement.aaho_office = objects['aaho_office']
requirement.from_shipment_date = objects['from_shipment_date']
requirement.to_shipment_date = objects['to_shipment_date']
requirement.from_city = objects['from_city']
requirement.to_city = objects['to_city']
requirement.tonnage = objects['tonnage']
requirement.no_of_vehicles = objects['no_of_vehicles']
requirement.material = objects['material']
requirement.type_of_vehicle = objects['type_of_vehicle']
requirement.rate = objects['rate']
requirement.remark = objects['remark']
requirement.cancel_reason = objects['cancel_reason']
requirement.changed_by = User.objects.get(username=request.user.username)
# print(request.data.get('req_status'))
if requirement.req_status and request.data.get('req_status') == 'open':
requirement.req_status = objects['req_status']
requirement.save(update_fields=[
'req_status', 'material', 'client', 'aaho_office',
'from_shipment_date', 'to_shipment_date', 'from_city', 'to_city',
'tonnage', 'no_of_vehicles', 'material', 'type_of_vehicle', 'rate',
'remark', 'cancel_reason', 'changed_by'
])
else:
requirement.req_status = objects['req_status']
requirement.save()
return json_response({'status': 'success', 'msg': 'requirement updated'})
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 trip_details(request, booking_id):
booking = ManualBooking.objects.get(id=booking_id)
data = {}
data.update({'status': 'success'})
data.update(
{
'basic_details': {
'lr_number': '\n'.join(booking.lr_numbers.values_list('lr_number', flat=True)),
'source_city': booking.from_city,
'destination_city': booking.to_city,
'shipment_date': None if not booking.shipment_date else booking.shipment_date.strftime('%d-%b-%Y'),
'vehicle_number': booking.lorry_number,
'weight': float(booking.supplier_charged_weight),
'rate': float(booking.supplier_rate),
'bill_number': 'OPB-{}'.format(
''.join(booking.outward_payment_bill.values_list('bill_number', flat=True))),
'pod_docs': [
{'url': pod.s3_url, 'thumb_url': pod.s3_thumb_url} for pod in booking.podfile_set.all()
]
}
}
)
data.update(
{
'rates': {
'weight': float(booking.supplier_charged_weight),
'rate': float(booking.supplier_rate),
'freight': int(float(booking.supplier_charged_weight) * float(booking.supplier_rate)),
'loading': booking.loading_charge,
'unloading': booking.unloading_charge,
'detention': booking.detention_charge,
'additional': booking.additional_charges_for_company,
'commission': booking.commission,
'lr_charge': booking.lr_cost,
'deduction_for_advance': booking.deduction_for_advance,
'deduction_for_balance': booking.deduction_for_balance,
'other_deduction': booking.other_deduction,
'total_amount_to_owner': int(booking.total_amount_to_owner),
'total_out_ward_amount': int(booking.total_out_ward_amount),
}
}
)
data.update(
{
'payments': [
{
'amount': float(payment.actual_amount),
'paid_to': payment.paid_to,
'remarks': payment.remarks,
'payment_mode': payment.get_payment_mode_display(),
'account_number': None if not payment.bank_account else payment.bank_account.account_number,
'fuel_card': None if not payment.fuel_card else payment.fuel_card.card_number,
'date': None if not payment.payment_date else payment.payment_date.strftime('%d-%b-%Y')
} for payment in booking.outward_booking.all().exclude(is_refund_amount=True)
]
}
)
return json_response(data=data)
def get_pod_details(request):
driver = request.driverapp_user
data = merge({
'status': 'success',
'msg': 'pod details',
}, driver_app_data(driver))
return json_response(data)
def complete_trip_details(request):
data = request.data
return json_response({
'basic_details':
get_basic_transaction_data(data.get("trans_id")),
'vehicle_info':
get_vehicle_data(data.get('trans_id')),
'payment_info':
get_payment_data(data.get('trans_id'))
})
def get_filtered_requirements(request):
# user = request.user
aaho_office_id = request.GET.get('aaho_office_id', None)
req_status = request.GET.get('requirement_status', None)
q_objects = Q()
if not aaho_office_id:
return json_response({
'status': 'failure',
'msg': 'Aaho Office ID is not passed'
})
if req_status not in [x[0] for x in REQ_STATUS]:
return json_response({
'status': 'failure',
'msg': 'Requirement status is wrong'
})
aaho_office = get_or_none(AahoOffice, id=aaho_office_id)
q_objects |= Q(**{'aaho_office': aaho_office, 'req_status': req_status})
present = datetime.datetime.now()
requirements = Requirement.objects.filter(q_objects).exclude(deleted=True)
requirements_with_todate = requirements.filter(
to_shipment_date__isnull=False,
from_shipment_date__lte=(present.date() + timedelta(days=3)),
to_shipment_date__gte=present.date())
requirements_without_todate = requirements.filter(
to_shipment_date__isnull=True,
from_shipment_date__range=(present.date(),
(present.date() + timedelta(days=3))))
requirements = requirements_with_todate.union(requirements_without_todate)
if not requirements:
return json_response({
'status': 'failure',
'msg': 'No requirements found',
'data': {}
})
return json_response({
'status': 'success',
'msg': 'requirements data',
'data': get_requirement_data(requirements)
})
def login_status(request):
if request.user and request.user.is_authenticated:
if request.user.is_active:
return json_response({
'status': 'success',
'state': 'logged_in',
'msg': 'user logged in and active'
})
else:
return json_response({
'status': 'success',
'state': 'inactive',
'msg': 'user logged in but inactive'
})
else:
return json_response({
'status': 'success',
'state': 'logged_out',
'msg': 'user logged out'
})
def app_data(request):
cities = City.objects.filter(
state_id__isnull=False).order_by('name').values(
'id', 'name', 'state__name')
cities = [{
'id': c['id'],
'name': c['name'],
'state': c['state__name']
} for c in cities]
vehicle_data = list(
VehicleCategory.objects.order_by('-priority').values(
'id', 'vehicle_type', 'capacity'))
vendor_data = list(
UserVendor.objects.filter(user=request.user).order_by('id').values(
'id', 'name', 'phone'))
customer_id = ''
aaho_office_id = ''
try:
sme = Sme.objects.get(name=request.user)
contact = ContactDetails.objects.filter(status='active',
sme=sme).order_by('type')[0]
customer_id = sme.id
aaho_office = sme.aaho_office
if not aaho_office:
aaho_office_id = sme.aaho_poc.office.id
else:
aaho_office_id = sme.aaho_office.id
# print(sme)
# print(customer_id)
# print(aaho_office_id)
except Sme.DoesNotExist:
return json_400_incorrect_use()
except IndexError:
contact = ContactDetails.objects.create(sme=sme,
name=request.user.first_name)
city_scores, address_scores = get_ranking_results(request.user.id)
data = {
'cities': cities,
'vehicles': vehicle_data,
'vendors': vendor_data,
'city_scores': city_scores,
'address_scores': address_scores,
'user': get_user_data(request.user, contact, sme),
'customer_id': customer_id,
'aaho_office_id': aaho_office_id
}
return json_response({
'status': 'success',
'msg': 'app data',
'data': data
})
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 app_version_check(request):
print("Request for app version check")
form = MobileAppVersionsForm(request.data)
if not form.is_valid():
return {'status': 'failure', 'msg': 'Pls enter all * fields'}
app_platform = request.data.get('app_platform')
app_name = request.data.get('app_name')
app_version = request.data.get('app_version')
mobile_app_version = MobileAppVersions.objects.filter(app_name=app_name, app_platform=app_platform).\
exclude(deleted=True).order_by('-created_on').first()
if not mobile_app_version:
return json_response({
'status':
'failure',
'msg':
'Mobile app {} version not found'.format(app_name)
})
if mobile_app_version.app_version == app_version:
force_upgrade = False
recommend_upgrade = False
else:
if mobile_app_version.upgrade_type == 'force':
force_upgrade = True
recommend_upgrade = False
else:
recommend_upgrade = True
force_upgrade = False
print("Returning : Request for app version check")
return json_response({
'status': 'success',
'msg': 'App version data',
'data': {
'forceUpgrade': force_upgrade,
'recommendUpgrade': recommend_upgrade,
'latest_version': mobile_app_version.app_version
}
})
def api_login(request):
username = request.data.get('username', None)
password = request.data.get('password', None)
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_response({'status': 'success', 'msg': 'login successful'})
def send_app_update_sms_to_fms_users(request):
if not request.data.get('app_link'):
return json_response({'status': 'failure', 'msg': 'Pls pass app link'})
brokers = Broker.objects.all().exclude(deleted=True)
mobiles_list = []
for broker in brokers:
if broker:
usr = broker.name
if any(g.name == 'fms' for g in usr.groups.all()):
if broker.get_phone() not in mobiles_list:
mobiles_list.append(broker.get_phone())
mobiles = ', '.join(mobiles_list)
print(mobiles)
template = "We have added new features to Aaho FMS app. Please click the link to update: {}".format(
request.data.get('app_link'))
print(template)
send_sms(mobiles, template)
return json_response({
'status': 'success',
'msg': 'Sms sent successfully to FMS users'
})
def team_booking_data(request, vehicle_id):
print(request.data)
if to_int(vehicle_id) != 9999999 and isinstance(get_or_none(Vehicle, id=vehicle_id), Vehicle):
vehicle = get_or_none(Vehicle, id=vehicle_id)
bookings = ManualBooking.objects.filter(
lorry_number__in=[display_format(compare_format(vehicle.vehicle_number))]).exclude(
booking_status__icontains='cancelled').order_by('-shipment_date')
else:
broker = Broker.objects.get(name=User.objects.get(username=request.user.username))
bookings = ManualBooking.objects.filter(supplier=broker,
shipment_date__gte=datetime(2017, 12, 1).date()).exclude(
booking_status__icontains='cancelled').order_by('-shipment_date')
return json_response({'status': 'success', 'data': supplier_booking_data(bookings=bookings)})
def edit_vehicle_status(request):
data = request.data
vehicle_status = data.get('vehicle_status', None)
if vehicle_status not in dict(VEHICLE_STATUS_CHOICES):
return json_response(
{
'status': 'error',
'msg': 'not a valid vehicle_status'
},
status=400)
driver = request.driverapp_user
driver.vehicle_status = vehicle_status
driver.save()
if isinstance(driver, DriverAppUser):
try:
gps_device = GPSDevice.objects.get(device_id=driver.device_id,
device_provider_id=7)
gps_device_serializer = GPSDeviceSerializer(
partial=True,
instance=gps_device,
data={'vehicle_status': vehicle_status})
if gps_device_serializer.is_valid():
gps_device_serializer.save()
except GPSDevice.DoesNotExist:
pass
if driver.number_verified:
Vehicle.objects.filter(driver_app_user=driver).update(
status=driver.vehicle_status)
data = merge({
'status': 'success',
'msg': 'vehicle_status updated',
}, driver_app_data(driver))
return json_response(data)
def edit_profile(request):
if not any((f in request.data) for f in [
'full_name', 'contact_name', 'address', 'phone', 'email',
'designation'
]):
return json_400_incorrect_use()
try:
sme = Sme.objects.get(name=request.user)
contact = ContactDetails.objects.filter(status='active',
sme=sme).order_by('type')[0]
except Sme.DoesNotExist:
return json_400_incorrect_use()
except IndexError:
contact = ContactDetails.objects.create(sme=sme)
if 'full_name' in request.data:
request.user.first_name = request.data['full_name']
request.user.save()
contact_mod = False
if 'contact_name' in request.data:
contact.name = request.data['contact_name']
contact_mod = True
if 'address' in request.data and request.data['address']:
save_sme_address(sme, request.data['address'])
if 'phone' in request.data:
contact.phone = request.data['phone']
contact_mod = True
if 'email' in request.data:
contact.email = request.data['email']
contact_mod = True
if 'designation' in request.data:
contact.designation = request.data['designation']
contact_mod = True
if contact_mod:
contact.save()
return json_response({
'status': 'success',
'msg': 'profile edited',
'user': get_user_data(request.user, contact, sme)
})
