def create(self, request):
role = user_role(request.user)
if (role == constants.VENDOR):
vendor_agent = VendorAgent.objects.get(user = request.user)
# REQUEST PARAM CHECK --------------------------------------------
try:
phone_number = request.data['phone_number']
name = request.data['name']
full_address = request.data['full_address']
pin_code = request.data['pin_code']
landmark = request.data.get('landmark')
except Exception, e:
content = {
'error':'Incomplete parameters',
'description':'Mandatory Fields: phone_number, name, full_address, pin_code, landmark [Optional]'
}
return Response(content, status = status.HTTP_400_BAD_REQUEST)
# -------------------------------------------------------------
new_consumer = fetch_or_create_consumer(phone_number, name, vendor_agent.vendor)
new_address = fetch_or_create_consumer_address(new_consumer, full_address, pin_code, landmark)
content = {
'consumer_id': new_consumer.id,
'new_address_id':new_address.id
}
return Response(content, status = status.HTTP_200_OK)
def add_address(self, request, pk):
try:
full_address = request.data['full_address']
pin_code = request.data['pin_code']
landmark = request.data.get('landmark')
except:
content = {
'error': 'Incomplete parameters',
'description': 'full_address, pin_code, landmark'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
vendor = vendor_agent.vendor
new_address = create_address(full_address, pin_code, landmark)
vendor.addresses.add(new_address)
content = {'description': 'Address added successfully'}
return Response(content, status=status.HTTP_200_OK)
else:
content = {
'description': 'You dont have permissions to add address.'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def remove_address(self, request, pk):
try:
address_id = request.data['address_id']
except:
content = {
'error': 'Incomplete params',
'description': 'address_id'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
role = user_role(request.user)
if role == constants.VENDOR:
address = get_object_or_404(Address, pk=address_id)
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
vendor = vendor_agent.vendor
vendor.addresses.remove(address)
content = {'description': 'Address removed successfully'}
return Response(content, status=status.HTTP_200_OK)
else:
content = {
'description': 'You dont have permissions to add address.'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def list(self, request):
page = self.request.QUERY_PARAMS.get('page', '1')
page = int(page)
role = user_role(request.user)
if role == constants.OPERATIONS:
employee = get_object_or_404(Employee, user=request.user)
notifications = employee.notifications.all().select_related(
'notification_type').order_by('-time_stamp')
notifications_count = len(notifications)
total_pages = int(
notifications_count / constants.PAGINATION_PAGE_SIZE) + 1
if page > total_pages or page <= 0:
response_content = {"error": "Invalid page number"}
return Response(response_content,
status=status.HTTP_400_BAD_REQUEST)
else:
notifications = paginate(notifications, page)
# ----------------------------------------------------------------------------
result = []
for notification in notifications:
notif_dict = notification_dict(notification)
result.append(notif_dict)
response_content = {
"data": result,
"total_pages": total_pages,
"total_notifications": notifications_count
}
return Response(response_content, status=status.HTTP_200_OK)
else:
content = {
'description': 'You dont have any notifications for now.'
}
return Response(status=status.HTTP_200_OK)
def list(self, request):
page = self.request.QUERY_PARAMS.get('page', '1')
page = int(page)
role = user_role(request.user)
if role == constants.OPERATIONS:
employee = get_object_or_404(Employee, user=request.user)
notifications = employee.notifications.all().select_related(
'notification_type').order_by('-time_stamp')
notifications_count = len(notifications)
total_pages = int(
notifications_count / constants.PAGINATION_PAGE_SIZE) + 1
if page > total_pages or page <= 0:
return response_invalid_pagenumber()
else:
notifications = paginate(notifications, page)
# ----------------------------------------------------------------------------
result = []
for notification in notifications:
notif_dict = notification_dict(notification)
result.append(notif_dict)
response_content = {
"data": result,
"total_pages": total_pages,
"total_notifications": notifications_count
}
return response_with_payload(response_content, None)
else:
success_message = 'You dont have any notifications for now.'
return response_success_with_message(success_message)
def retrieve(self, request, pk=None):
role = user_role(request.user)
if role == constants.OPERATIONS:
employee = get_object_or_404(Employee, user=request.user)
notification = get_object_or_404(Notification, pk=pk)
all_notifications = employee.notifications.all()
is_permitted = False
for notif in all_notifications:
if notification.id == notif.id:
is_permitted = True
break
if is_permitted == True:
notif_dict = notification_dict(notification)
return Response(notif_dict, status=status.HTTP_200_OK)
else:
content = {
'error':
'You dont have permissions to view notification details'
}
return Response(content,
status=status.HTTP_405_METHOD_NOT_ALLOWED)
else:
content = {
'error':
'You dont have permissions to view notification details.'
}
return Response(content, status=status.HTTP_405_METHOD_NOT_ALLOWED)
def add_address(self, request, pk):
try:
flat_number = request.data['flat_number']
building = request.data['building']
street = request.data['street']
area_code = request.data['area_code']
except:
content = {
'error': 'Incomplete params',
'description': 'flat_number, building, street, area_code'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
area = get_object_or_404(Area, area_code=area_code)
new_address = Address.objects.create(flat_number=flat_number,
building=building,
street=street,
area=area)
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
vendor = vendor_agent.vendor
vendor.addresses.add(new_address)
content = {'description': 'Address added successfully'}
return Response(content, status=status.HTTP_200_OK)
else:
content = {
'description': 'You dont have permissions to add address.'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def read(self, request, pk):
role = user_role(request.user)
if role == constants.OPERATIONS:
employee = get_object_or_404(Employee, user=request.user)
notification = get_object_or_404(Notification, pk=pk)
all_notifications = employee.notifications.all()
is_permitted = False
for notif in all_notifications:
if notification.id == notif.id:
is_permitted = True
break
if is_permitted == True:
notification.read = True
notification.save()
return Response(status=status.HTTP_200_OK)
else:
content = {
'error':
'You dont have permissions to update this notification'
}
return Response(content,
status=status.HTTP_405_METHOD_NOT_ALLOWED)
else:
content = {
'description':
'You dont have permissions to update this notification'
}
return Response(status=status.HTTP_200_OK)
def create(self, request):
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent,
user=self.request.user)
vendor = vendor_agent.vendor
try:
name = request.data['name']
description = request.data['description']
cost_string = request.data['cost']
cost = float(cost_string)
except:
content = {
'error':
'missing params with name, description, cost, vendor'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
new_product = Product.objects.create(vendor=vendor,
name=name,
description=description,
cost=cost)
serializer = ProductSerializer(new_product)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
content = {'error': 'You dont have permissions to add a product'}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def destroy(self, request, pk):
role = user_role(request.user)
product = get_object_or_404(Product, pk=pk)
if (role == constants.VENDOR):
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
vendor = vendor_agent.vendor
if product.vendor == vendor:
product.delete()
content = {'description': 'Product deleted Successfully.'}
return Response(content, status=status.HTTP_200_OK)
else:
content = {
'description':
'You dont have permissions to delete this product.'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
else:
content = {
'description':
'You dont have permissions to delete this order.'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def pending(self, request):
role = user_role(request.user)
if role == constants.OPERATIONS:
employee = get_object_or_404(Employee, user=request.user)
notifications_count = employee.notifications.filter(
read=False).count()
return response_with_payload(notifications_count, None)
else:
success_message = 'You dont have any pending notifications for now.'
return response_success_with_message(success_message)
def list(self, request):
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = VendorAgent.objects.get(user=self.request.user)
products_of_vendor = Product.objects.filter(
vendor=vendor_agent.vendor).order_by(Lower('name'))
serializer = ProductSerializer(products_of_vendor, many=True)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
content = {'error': 'You dont have permissions to view products'}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def list(self, request):
page = self.request.QUERY_PARAMS.get('page', None)
search_query = request.QUERY_PARAMS.get('search', None)
addresses_required = False
if page is not None:
page = int(page)
else:
page = 1
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user = request.user)
total_consumers_of_vendor = Consumer.objects.filter(vendor = vendor_agent.vendor).order_by(Lower('full_name'))
# SEARCH KEYWORD FILTERING -------------------------------------------------
if search_query is not None:
total_consumers_of_vendor = total_consumers_of_vendor.filter(Q(full_name__icontains=search_query) | Q(phone_number=search_query))
addresses_required = True
# --------------------------------------------------------------------------
# FETCH ADDRESSES OF CUSTOMER ----------------------------------------------
if addresses_required:
total_consumers_of_vendor = total_consumers_of_vendor.prefetch_related('addresses')
# --------------------------------------------------------------------------
# PAGINATE -----------------------------------------------------------------
total_customers_count = len(total_consumers_of_vendor)
total_pages = int(total_customers_count/constants.PAGINATION_PAGE_SIZE) + 1
if page > total_pages or page<=0:
response_content = {
"error": "Invalid page number"
}
return Response(response_content, status = status.HTTP_400_BAD_REQUEST)
else:
customers = paginate(total_consumers_of_vendor, page)
result = []
for consumer in customers:
if addresses_required:
consumer_dict = consumer_detail_dict(consumer)
else:
consumer_dict = consumer_list_dict(consumer)
result.append(consumer_dict)
response_content = { "data": result, "total_pages": total_pages }
return Response(response_content, status = status.HTTP_200_OK)
else:
content = {'error':'You dont have permissions to view all Consumers'}
return Response(content, status = status.HTTP_400_BAD_REQUEST)
def pending(self, request):
role = user_role(request.user)
if role == constants.OPERATIONS:
employee = get_object_or_404(Employee, user=request.user)
notifications_count = employee.notifications.filter(
read=False).count()
response_content = {"count": notifications_count}
return Response(response_content, status=status.HTTP_200_OK)
else:
content = {
'description':
'You dont have any pending notifications for now.'
}
return Response(status=status.HTTP_200_OK)
def retrieve(self, request, pk = None):
consumer = get_object_or_404(Consumer, id = pk)
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user = request.user)
if consumer.vendor.id == vendor_agent.vendor.id:
detail_dict = consumer_detail_dict(consumer)
return Response(detail_dict, status = status.HTTP_200_OK)
else:
content = {'error':'You dont have permissions to view this consumer.'}
return Response(content, status = status.HTTP_400_BAD_REQUEST)
else:
content = {'error':'You dont have permissions to view this consumer.'}
return Response(content, status = status.HTTP_400_BAD_REQUEST)
def list(self, request):
role = user_role(request.user)
if (role == constants.SALES) or (role == constants.OPERATIONS):
all_vendors = Vendor.objects.filter(verified=True).order_by(
Lower('store_name'))
serializer = VendorSerializer(all_vendors, many=True)
return Response(serializer.data, status=status.HTTP_201_CREATED)
elif role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
serializer = VendorSerializer(vendor_agent.vendor)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
content = {
'error': 'You dont have permissions to view all vendors'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def list(self, request):
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
consumers_of_vendor = Consumer.objects.filter(
vendor=vendor_agent.vendor).order_by(Lower('full_name'))
serializer = ConsumerSerializer(consumers_of_vendor, many=True)
return Response(serializer.data, status=status.HTTP_201_CREATED)
elif role == constants.OPERATIONS:
all_customers = Consumer.objects.all()
serializer = ConsumerSerializer(all_customers, many=True)
else:
content = {
'error': 'You dont have permissions to view all Consumers'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def all_vendor_emails(self, request):
role = user_role(request.user)
if role == constants.OPERATIONS:
vendors = Vendor.objects.filter(verified=True)
all_emails = ''
for vendor in vendors:
all_emails = all_emails + vendor.email
all_emails = all_emails + ','
content = {'all_emails': all_emails}
return Response(content, status=status.HTTP_200_OK)
else:
content = {
'error': 'No permissions',
'description': 'You dont have permissions to access this.'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def requestedvendors(self, request):
role = user_role(request.user)
if (role == constants.SALES) or (role == constants.OPERATIONS):
all_vendors = Vendor.objects.filter(verified=False).order_by(
Lower('store_name'))
all_vendors_array = []
for vendor in all_vendors:
vendor_dict = vendor_list_dict(vendor)
all_vendors_array.append(vendor_dict)
response_content = {"data": all_vendors_array}
return Response(response_content, status=status.HTTP_200_OK)
else:
content = {
'error': 'You dont have permissions to view all vendors'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
role = user_role(request.user)
if (role == constants.VENDOR) or (role == constants.SALES):
try:
vendor_id = request.data['vendor_id']
phone_number = request.data['phone_number']
name = request.data.get('name')
password = request.data['password']
except Exception, e:
content = {
'error': 'Incomplete params',
'description': 'vendor_id, phone_number, name, password'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
try:
vendor = Vendor.objects.get(id=vendor_id)
except:
content = {'error': 'Vendor with id doesnt exists'}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
if is_userexists(phone_number) is True:
user = User.objects.get(username=phone_number)
if is_vendoragentexists(user) is True:
content = {
'error': 'Vendor Agent with same details exists'
}
return Response(content,
status=status.HTTP_400_BAD_REQUEST)
else:
vendor_agent = VendorAgent.objects.create(user=user)
else:
user = User.objects.create(username=phone_number,
password=password)
new_vendor_agent = VendorAgent.objects.create(user=user,
vendor=vendor)
# GROUP SETTING
group = Group.objects.get(name=constants.VENDOR)
group.user_set.add(user)
token = create_token(user, constants.VENDOR)
content = {'auth_token': token.key}
return Response(content, status=status.HTTP_201_CREATED)
def retrieve(self, request, pk=None):
role = user_role(request.user)
if role == constants.OPERATIONS:
employee = get_object_or_404(Employee, user=request.user)
notification = get_object_or_404(Notification, pk=pk)
all_notifications = employee.notifications.all()
is_permitted = False
for notif in all_notifications:
if notification.id == notif.id:
is_permitted = True
break
if is_permitted == True:
notif_dict = notification_dict(notification)
return response_with_payload(notif_dict, None)
else:
return response_access_denied()
else:
return response_access_denied()
def get_open_ticket_count(request):
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
vendor = vendor_agent.vendor
url = '{}/helpdesk/tickets.json?email={}&filter_name=new_and_my_open'.format(
constants.FRESHDESK_BASEURL, vendor.email)
elif role == constants.OPERATIONS:
url = '{}/helpdesk/tickets/filter/new_and_my_open?format=json'.format(
constants.FRESHDESK_BASEURL)
else:
return response_access_denied()
try:
r = requests.get(url, headers=auth_headers())
content = r.json()
response = {'count': len(content)}
return Response(response, status=status.HTTP_200_OK)
except Exception, e:
content = {'error': 'Something went wrong'}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def read(self, request, pk):
role = user_role(request.user)
if role == constants.OPERATIONS:
employee = get_object_or_404(Employee, user=request.user)
notification = get_object_or_404(Notification, pk=pk)
all_notifications = employee.notifications.all()
is_permitted = False
for notif in all_notifications:
if notification.id == notif.id:
is_permitted = True
break
if is_permitted == True:
notification.read = True
notification.save()
success_message = 'Notification marked as read.'
return response_success_with_message(success_message)
else:
return response_access_denied()
else:
return response_access_denied()
def all_tickets(request):
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
vendor = vendor_agent.vendor
url = '{}/helpdesk/tickets.json?email={}&filter_name=all_tickets'.format(
constants.FRESHDESK_BASEURL, vendor.email)
elif role == constants.OPERATIONS:
url = '{}/helpdesk/tickets/filter/all_tickets?format=json'.format(
constants.FRESHDESK_BASEURL)
else:
content = {'error': 'You dont have permissions'}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
try:
r = requests.get(url, headers=auth_headers())
return Response(r.json(), status=status.HTTP_200_OK)
except Exception, e:
content = {'error': 'Something went wrong'}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def file_download(self, request):
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user = request.user)
all_consumers_of_vendor = Consumer.objects.filter(vendor = vendor_agent.vendor).order_by(Lower('full_name'))
result = []
for consumer in all_consumers_of_vendor:
consumer_dict = excel_download_consumer_detail(consumer)
result.append(consumer_dict)
response_content = {
"data": result
}
return Response(response_content, status = status.HTTP_200_OK)
else:
content = {
'error':'No permissions to access customers',
'description':'You dont have permissions to fetch customers list'
}
return Response(content, status = status.HTTP_400_BAD_REQUEST)
def create(self, request):
role = user_role(request.user)
if (role == constants.VENDOR):
vendor_agent = VendorAgent.objects.get(user=request.user)
try:
phone_number = request.data['phone_number']
name = request.data['name']
except Exception, e:
content = {
'error': 'Incomplete params',
'description': 'Mandatory Fields: phone_number, name'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
## ADDING ADDRESS
try:
flat_number = request.data['flat_number']
building = request.data['building']
street = request.data['street']
area_code = request.data['area_code']
area = get_object_or_404(Area, area_code=area_code)
except:
content = {
'error':
'Address details missing',
'description':
'Mandatory Fields: flat_number, building, street, area_code'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
consumer = fetch_or_create_consumer(phone_number, name, vendor)
full_address = flat_number + building + street
address = fetch_or_create_consumer_address(consumer, full_address,
None, None)
serializer = ConsumerSerializer(consumer)
content = {'consumer': serializer.data}
return Response(content, status=status.HTTP_201_CREATED)
def add_address(self, request, pk):
try:
full_address = request.data['full_address']
pin_code = request.data['pin_code']
landmark = request.data.get('landmark')
except:
content = {
'error':'Incomplete parameters',
'description':'full_address, pin_code, landmark [optional]'
}
return Response(content, status = status.HTTP_400_BAD_REQUEST)
role = user_role(request.user)
if role == constants.VENDOR:
consumer = get_object_or_404(Consumer, pk = pk)
new_address = fetch_or_create_consumer_address(consumer, full_address, pin_code, landmark)
content = {
'address_id': new_address.id
}
return Response(content, status = status.HTTP_200_OK)
else:
content = {'description': 'You dont have permissions to add address.'}
return Response(content, status = status.HTTP_400_BAD_REQUEST)
def retrieve(self, request, pk=None):
vendor = get_object_or_404(Vendor, id=pk)
role = user_role(request.user)
can_respond = False
if role == 'vendor':
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
if vendor.id == vendor_agent.vendor.id:
can_respond = True
else:
can_respond = False
else:
can_respond = True
if can_respond:
vendor_detail = vendor_detail_dict(vendor)
response_content = {"data": vendor_detail}
return Response(response_content, status=status.HTTP_200_OK)
else:
content = {
'error':
'You dont have permissions to view this vendor details.'
}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
end_date_string = request.data['end_date']
start_date = parse_datetime(start_date_string)
start_date = ist_day_start(start_date)
end_date = parse_datetime(end_date_string)
end_date = ist_day_end(end_date)
except Exception, e:
content = {'error': 'Error in params: start_date, end_date'}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
# ---------------------------------------------------------------
# VENDOR INPUTS ---------------------------------------------------
vendor = None
role = user_role(request.user)
if role == constants.VENDOR:
vendor_agent = get_object_or_404(VendorAgent, user=request.user)
vendor = vendor_agent.vendor
else:
vendor_id = request.data.get('vendor_id')
if vendor_id is not None:
vendor = get_object_or_404(Vendor, pk=vendor_id)
else:
pass
# --------------------------------------------------------------------
# VENDOR FILTERING ---------------------------------------------------
if vendor is not None:
delivery_status_queryset = OrderDeliveryStatus.objects.filter(
order__vendor=vendor)
