def list(self, request): role = user_role(request.user) search = request.QUERY_PARAMS.get('search', None) page = request.QUERY_PARAMS.get('page', '1') 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')).prefetch_related('timeslots') if search is not None: products_of_vendor = products_of_vendor.filter( Q(name__icontains=search)) # PAGINATION ---------------------------------------------------------------- total_product_count = len(products_of_vendor) page = int(page) total_pages = int( total_product_count / constants.PAGINATION_PAGE_SIZE) + 1 if page > total_pages or page <= 0: return response_invalid_pagenumber() else: result_products = paginate(products_of_vendor, page) # ---------------------------------------------------------------------------- result = [] for product in result_products: product_dict = product_list_dict(product) result.append(product_dict) response_content = { "data": result, "total_pages": total_pages, "total_product_count": total_product_count } return response_with_payload(response_content, None) else: return response_access_denied()
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 list(self, request): role = user_role(request.user) is_verified = request.QUERY_PARAMS.get('is_verified', None) search = request.QUERY_PARAMS.get('search', None) page = request.QUERY_PARAMS.get('page', '1') if (role == constants.HR) or (role == constants.SALES) or ( role == constants.OPERATIONS) or (role == constants.ACCOUNTS): all_vendors = Vendor.objects.all().order_by(Lower('store_name')) if search is not None: all_vendors = all_vendors.filter( Q(store_name__icontains=search)) if is_verified is not None: is_verified = json.loads(is_verified.lower()) if is_verified is True: all_vendors = all_vendors.filter(verified=True) else: all_vendors = all_vendors.filter(verified=False) # PAGINATION ---------------------------------------------------------------- total_vendor_count = len(all_vendors) page = int(page) total_pages = int( total_vendor_count / constants.PAGINATION_PAGE_SIZE) + 1 if page > total_pages or page <= 0: return response_invalid_pagenumber() else: result_vendors = paginate(all_vendors, page) # ---------------------------------------------------------------------------- result = [] for vendor in result_vendors: vendor_dict = vendor_list_dict(vendor) result.append(vendor_dict) response_content = { "data": result, "total_pages": total_pages, "total_vendor_count": total_vendor_count } return response_with_payload(response_content, None) elif role == constants.VENDOR: vendor_agent = get_object_or_404(VendorAgent, user=request.user) vendor_detail = vendor_detail_dict(vendor_agent.vendor) return response_with_payload(vendor_detail, None) else: return response_access_denied()
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 groups(request): url = '{}/groups.json'.format(constants.FRESHDESK_BASEURL) try: r = requests.get(url, headers=auth_headers()) content = r.json() return response_with_payload(content, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message)
def get_ticket(request): ticket_id = request.QUERY_PARAMS.get('ticket_id', None) url = '{}/helpdesk/tickets/{}.json'.format(constants.FRESHDESK_BASEURL, ticket_id) try: r = requests.get(url, headers=auth_headers()) content = r.json() return response_with_payload(content, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message)
def create_ticket(request): url = '{}api/v2/tickets'.format(constants.FRESHDESK_BASEURL) try: r = requests.post(url, data=json.dumps(request.data), headers=auth_headers()) content = r.json() return response_with_payload(content, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message)
def add_note(request): ticket_id = request.data['id'] note = request.data['note'] url = '{}/helpdesk/tickets/{}/conversations/note.json'.format( constants.FRESHDESK_BASEURL, ticket_id) try: r = requests.post(url, data=json.dumps(note), headers=auth_headers()) content = r.json() return response_with_payload(content, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message)
def profile(request): role = user_role(request.user) if role == constants.VENDOR: vendor_agent = VendorAgent.objects.get(user=request.user) name = vendor_agent.vendor.store_name elif role == constants.OPERATIONS or role == constants.OPERATIONS_MANAGER or role == constants.SALES or role == constants.HR or role == constants.ACCOUNTS or role == constants.CALLER: employee = Employee.objects.get(user=request.user) name = employee.user.first_name else: return response_access_denied() result = {'name': name, 'role': role} return response_with_payload(result, None)
def list(self, request): role = user_role(request.user) if role == constants.VENDOR: vendor_agent = VendorAgent.objects.get(user=request.user) vendor_agents_of_vendor = VendorAgent.objects.filter( vendor=vendor_agent.vendor) vendoragents = [] for agent in vendor_agents_of_vendor: vendor_agent_dict = vendor_agent_list_dict(agent) vendoragents.append(vendor_agent_dict) content = {"vendor_agents": vendor_agent_dict} return response_with_payload(content, None) else: return response_access_denied()
def all_tickets(request): role = user_role(request.user) page = request.QUERY_PARAMS.get('page', 1) page = int(page) if role == constants.VENDOR: vendor_agent = get_object_or_404(VendorAgent, user=request.user) vendor = vendor_agent.vendor url = '{}api/v2/tickets?updated_since=2015-01-19T02:00:00Z&email={}&per_page={}&page={}'.format( constants.FRESHDESK_BASEURL, vendor.email, constants.FRESHDESK_PAGE_COUNT, page) elif role == constants.OPERATIONS: url = '{}api/v2/tickets?updated_since=2015-01-19T02:00:00Z&per_page={}&page={}'.format( constants.FRESHDESK_BASEURL, constants.FRESHDESK_PAGE_COUNT, page) else: return response_access_denied() try: if role == constants.VENDOR: vendor_agent = get_object_or_404(VendorAgent, user=request.user) vendor = vendor_agent.vendor count_url = '{}helpdesk/tickets/summary.json?view_name=all&email={}'.format( constants.FRESHDESK_BASEURL, vendor.email) elif role == constants.OPERATIONS: count_url = '{}helpdesk/tickets/summary.json?view_name=all'.format( constants.FRESHDESK_BASEURL) else: return response_access_denied() count_request = requests.get(count_url, headers=auth_headers()) count_response = count_request.json() count = count_response['view_count'] total_pages = int(count / constants.FRESHDESK_PAGE_COUNT) + 1 r = requests.get(url, headers=auth_headers()) content = r.json() response_content = { "data": content, "total_pages": total_pages, "total_tickets": count } return response_with_payload(response_content, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message)
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 APIException: params = ['vendor_id', 'phone_number', 'name', 'password'] return response_incomplete_parameters(params) try: vendor = Vendor.objects.get(id=vendor_id) except APIException: error_message = 'Vendor with id doesnt exists' return response_error_with_message(error_message) if is_userexists(phone_number) is True: user = User.objects.get(username=phone_number) if is_vendoragentexists(user) is True: error_message = 'Vendor Agent with same details exists' return response_error_with_message(error_message) else: vendor_agent = VendorAgent.objects.create(user=user) else: user = User.objects.create(username=phone_number, password=password, first_name=name) new_vendor_agent = VendorAgent.objects.create(user=user, vendor=vendor) # GROUP SETTING try: group = Group.objects.get(name=constants.VENDOR) group.user_set.add(user) except Exception as e: log_exception(e, 'Group settings failed for vendor agent') token = create_token(user, constants.VENDOR) return response_with_payload(token.key, None) else: return response_access_denied()
def servicible_pincodes(request): role = user_role(request.user) if role == constants.VENDOR or \ role == constants.OPERATIONS or \ role == constants.OPERATIONS_MANAGER or \ role == constants.HR or \ role == constants.SALES or \ role == constants.SALES_MANAGER: all_pincodes = ServiceablePincode.objects.all() result = [] for pincode in all_pincodes: pincode_dict = { 'pincode': pincode.pincode, 'city': pincode.city.city_name } result.append(pincode_dict) return response_with_payload(result, None) else: return response_access_denied()
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 retrieve(self, request, pk=None): vendor = get_object_or_404(Vendor, id=pk) role = user_role(request.user) can_respond = False if role == constants.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) return response_with_payload(vendor_detail, None) else: return response_access_denied()
def get_open_ticket_count(request): try: role = user_role(request.user) if role == constants.VENDOR: vendor_agent = get_object_or_404(VendorAgent, user=request.user) vendor = vendor_agent.vendor count_url = '{}helpdesk/tickets/summary.json?view_name=open&email={}'.format( constants.FRESHDESK_BASEURL, vendor.email) elif role == constants.OPERATIONS: count_url = '{}helpdesk/tickets/summary.json?view_name=open'.format( constants.FRESHDESK_BASEURL) else: return response_access_denied() count_request = requests.get(count_url, headers=auth_headers()) count_response = count_request.json() count = count_response['view_count'] return response_with_payload(count, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message)
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 Exception as e: params = ['name' 'description', 'cost', 'vendor'] return response_incomplete_parameters(params) new_product = Product.objects.create(vendor=vendor, name=name, description=description, cost=cost) product_dict = product_list_dict(new_product) return response_with_payload(product_dict, None) else: return response_access_denied()
def login(request): try: username = request.data['username'] password = request.data['password'] except APIException: params = ['username', 'password'] return response_incomplete_parameters(params) try: user = authenticate(username=username, password=password) role = user_role(user) except Exception as e: error_message = 'No such user found or No such token found for the role' return response_error_with_message(error_message) if role == constants.DELIVERY_GUY: dg = get_object_or_404(DeliveryGuy, user=user) if dg.is_active is True: try: auth_login(request, user) user_details = dg_details_dict(dg) token = Token.objects.get(user=user) if token is not None: auth_token = token.key user_details['auth_token'] = auth_token user_details['role'] = role content = user_details return response_with_payload(content, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message) else: error_message = 'This DG is deactive' return response_error_with_message(error_message) elif role == constants.VENDOR: vendor_agent = get_object_or_404(VendorAgent, user=user) try: auth_login(request, user) vendor_details = vendor_details_dict(vendor_agent) token = Token.objects.get(user=user) if token is not None: auth_token = token.key vendor_details['auth_token'] = auth_token vendor_details['role'] = role content = vendor_details return response_with_payload(content, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message) else: emp = get_object_or_404(Employee, user=user) try: auth_login(request, user) emp_details = emp_details_dict(emp) token = Token.objects.get(user=user) if token is not None: auth_token = token.key emp_details['auth_token'] = auth_token emp_details['role'] = emp.department content = emp_details return response_with_payload(content, None) except Exception as e: error_message = 'Something went wrong' return response_error_with_message(error_message)
def register(request): try: role = request.data['role'] phone_number = request.data['phone_number'] password = request.data['password'] name = request.data['name'] email = request.data.get('email') vendor_id = request.data.get('vendor_id') except APIException: params = [ 'role', 'phone_number', 'password', 'name', 'email(optional)', 'vendor_id(optional)' ] return response_incomplete_parameters(params) # CHECK IF USER EXISTS ----------------------------------- if is_userexists(phone_number): error_message = 'User with same phone number already exists' return response_error_with_message(error_message) # ----------------------------------------------------------- # VENDOR AGENT CREATION NEEDS VENDOR_ID ---------------------- if role == constants.VENDOR: if vendor_id is None: params = ['vendor_id'] return response_incomplete_parameters(params) try: vendor = Vendor.objects.get(id=vendor_id) except APIException: error_message = 'Vendor with given id doesnt exists' return response_error_with_message(error_message) # --------------------------------------------------------------- user = User.objects.create_user(username=phone_number, password=password, first_name=name) if email is not None: user.email = email user.save() token = None if role == constants.VENDOR: token = create_token(user, constants.VENDOR) vendor = get_object_or_404(Vendor, id=vendor_id) vendor_agent = VendorAgent.objects.create(user=user, vendor=vendor) assign_usergroup(user) elif role == constants.DELIVERY_GUY: token = create_token(user, constants.DELIVERY_GUY) delivery_guy = DeliveryGuy.objects.create(user=user) assign_usergroup(user) elif role == constants.OPERATIONS: token = create_token(user, constants.OPERATIONS) employee = Employee.objects.create(user=user) employee.department = constants.OPERATIONS assign_usergroup(user) elif role == constants.OPERATIONS_MANAGER: token = create_token(user, constants.OPERATIONS_MANAGER) employee = Employee.objects.create(user=user) employee.department = constants.OPERATIONS_MANAGER assign_usergroup(user) elif role == constants.SALES: token = create_token(user, constants.SALES) employee = Employee.objects.create(user=user) employee.department = constants.SALES assign_usergroup(user) elif role == constants.HR: token = create_token(user, constants.HR) employee = Employee.objects.create(user=user) employee.department = constants.HR assign_usergroup(user) elif role == constants.ACCOUNTS: token = create_token(user, constants.ACCOUNTS) employee = Employee.objects.create(user=user) employee.department = constants.ACCOUNTS assign_usergroup(user) elif role == constants.CALLER: token = create_token(user, constants.CALLER) employee = Employee.objects.create(user=user) employee.department = constants.CALLER assign_usergroup(user) else: token = None employee.save() if token is not None: content = {'auth_token': token.key} else: content = {'auth_token': None, 'user created for group: ': role} return response_with_payload(content, None)
def dashboard_stats(request): try: start_date_string = request.QUERY_PARAMS.get('start_date', None) end_date_string = request.QUERY_PARAMS.get('end_date', None) start_date = parse_datetime(start_date_string) start_date = ist_datetime(start_date) end_date = parse_datetime(end_date_string) end_date = ist_datetime(end_date) except Exception as e: params = ['start_date', 'end_date'] return response_incomplete_parameters(params) # CREATE DATE RULE ----------------------------------------------------------- rule_daily = rrule(DAILY, dtstart=start_date, until=end_date) alldates = list(rule_daily) # VENDOR FILTERING ----------------------------------------------------------- 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.QUERY_PARAMS.get('vendor_id', None) if vendor_id is not None: vendor = get_object_or_404(Vendor, pk=vendor_id) else: pass if vendor is not None: delivery_status_queryset = OrderDeliveryStatus.objects.filter( order__vendor=vendor) else: delivery_status_queryset = OrderDeliveryStatus.objects.all() # DATE FILTERING --------------------------------------------------------------- delivery_status_queryset = delivery_status_queryset.filter( date__gte=start_date, date__lte=end_date) total_orders = delivery_status_queryset.filter( Q(order_status=constants.ORDER_STATUS_QUEUED) | Q(order_status=constants.ORDER_STATUS_INTRANSIT) | Q(order_status=constants.ORDER_STATUS_OUTFORDELIVERY) | Q(order_status=constants.ORDER_STATUS_DELIVERED) | Q(order_status=constants.ORDER_STATUS_DELIVERY_ATTEMPTED)).count() # ORDER STATUS FILTERING ------------------------------------------------------- total_orders_executed = delivery_status_queryset.filter( Q(order_status=constants.ORDER_STATUS_DELIVERED) | Q(order_status=constants.ORDER_STATUS_DELIVERY_ATTEMPTED)).count() # TOTAL COD TO BE COLLECTED ----------------------------- executable_deliveries = delivery_status_queryset.filter( Q(order_status=constants.ORDER_STATUS_QUEUED) | Q(order_status=constants.ORDER_STATUS_INTRANSIT) | Q(order_status=constants.ORDER_STATUS_OUTFORDELIVERY) | Q(order_status=constants.ORDER_STATUS_DELIVERED)) total_cod_dict = executable_deliveries.aggregate( total_cod=Sum('order__cod_amount')) total_cod = total_cod_dict['total_cod'] # TOTAL COD COLLECTED ------------------------------------ executed_deliveries = delivery_status_queryset.filter( Q(order_status=constants.ORDER_STATUS_DELIVERED)) total_cod_dict = executed_deliveries.aggregate( total_cod=Sum('cod_collected_amount')) cod_collected = total_cod_dict['total_cod'] # FOR ORDER COUNT FOR INDIVIDUAL DATES ----------------------------------------- fullday_timedelta = timedelta(hours=23, minutes=59) orders_graph = [] for date in alldates: day_start = date day_end = day_start + fullday_timedelta delivery_status_per_date = delivery_status_queryset.filter( date__gte=day_start, date__lte=day_end) total_orders_per_day = delivery_status_per_date.count() orders_delivered_count = delivery_status_per_date.filter( Q(order_status=constants.ORDER_STATUS_DELIVERED)).count() orders_delivered_attempted_count = delivery_status_per_date.filter( Q(order_status=constants.ORDER_STATUS_DELIVERY_ATTEMPTED)).count() orders_pickup_attempted_count = delivery_status_per_date.filter( Q(order_status=constants.ORDER_STATUS_PICKUP_ATTEMPTED)).count() orders_cancelled_count = delivery_status_per_date.filter( Q(order_status=constants.ORDER_STATUS_CANCELLED)).count() orders_undelivered_count = delivery_status_per_date.filter( Q(order_status=constants.ORDER_STATUS_PLACED) | Q(order_status=constants.ORDER_STATUS_QUEUED)).count() orders_intransit_count = delivery_status_per_date.filter( Q(order_status=constants.ORDER_STATUS_OUTFORDELIVERY) | Q(order_status=constants.ORDER_STATUS_INTRANSIT)).count() ist_timedelta = timedelta(hours=5, minutes=30) display_date = date + ist_timedelta result = { 'total_orders_count': total_orders_per_day, 'delivered_count': orders_delivered_count, 'delivery_attempted_count': orders_delivered_attempted_count, 'pickup_attempted_count': orders_pickup_attempted_count, 'cancelled_count': orders_cancelled_count, 'queued_count': orders_undelivered_count, 'intransit_count': orders_intransit_count, 'date': display_date.date() } orders_graph.append(result) content = { 'total_orders': total_orders, 'total_orders_executed': total_orders_executed, 'total_cod': total_cod, 'cod_collected': cod_collected, 'orders': orders_graph } return response_with_payload(content, None)
def excel_download(request): try: start_date_string = request.QUERY_PARAMS.get('start_date', None) end_date_string = request.QUERY_PARAMS.get('end_date', None) 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 as e: params = ['start_date', 'end_date'] return response_incomplete_parameters(params) # VENDOR FILTERING ----------------------------------------------------------- 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.QUERY_PARAMS.get('vendor_id', None) if vendor_id is not None: vendor = get_object_or_404(Vendor, pk=vendor_id) else: pass if vendor is not None: delivery_status_queryset = OrderDeliveryStatus.objects.filter( order__vendor=vendor).select_related('delivery_guy__user') else: delivery_status_queryset = OrderDeliveryStatus.objects.all( ).select_related('delivery_guy__user') # DATE FILTERING --------------------------------------------------------------- delivery_status_queryset = delivery_status_queryset.filter( date__gte=start_date, date__lte=end_date).select_related('order') # ------------------------------------------------------------------------------ if len(delivery_status_queryset) > 5000: error_message = 'Too many records. Max of 5000 deliveries can be downloaded at a time.' return response_error_with_message(error_message) # CONSTRUCTING RESPONSE --------------------------------------------------------------- ist_timedelta = timedelta(hours=5, minutes=30) excel_order_details = [] for delivery_status in delivery_status_queryset: try: date = delivery_status.date + ist_timedelta order = delivery_status.order excel_order = { 'date': date.strftime('%d-%m-%Y'), 'order_id': delivery_status.id, 'customer_name': order.consumer.full_name, 'customer_phone_number': order.consumer.phone_number, 'cod_amount': order.cod_amount, 'cod_collected': delivery_status.cod_collected_amount, 'cod_reason': delivery_status.cod_remarks, 'status': delivery_status.order_status, 'vendor_notes': order.notes, 'vendor_order_id': order.vendor_order_id } if role == constants.OPERATIONS: excel_order['vendor_name'] = order.vendor.store_name if delivery_status.delivery_guy is not None: excel_order[ 'delivery_guy'] = delivery_status.delivery_guy.user.first_name else: excel_order['delivery_guy'] = None excel_order_details.append(excel_order) except Exception as e: pass return response_with_payload(excel_order_details, None)