def resolve(request):
ticket_id = request.data['id']
note = request.data.get('note')
resolve = request.data['resolve']
if note is not None:
note_url = '{}/helpdesk/tickets/{}/conversations/note.json'.format(
constants.FRESHDESK_BASEURL, ticket_id)
else:
pass
resolve_url = '{}/helpdesk/tickets/{}.json'.format(
constants.FRESHDESK_BASEURL, ticket_id)
try:
if note is not None and note_url is not None:
note_request = requests.post(note_url,
data=json.dumps(note),
headers=auth_headers())
resolve_request = requests.put(resolve_url,
data=json.dumps(resolve),
headers=auth_headers())
success_message = 'Successfully resolved the ticket'
return response_success_with_message(success_message)
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 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 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 request_vendor_account(self, request, pk=None):
try:
store_name = request.data['store_name']
phone_number = request.data['phone_number']
email = request.data['email']
full_address = request.data['full_address']
pin_code = request.data['pin_code']
landmark = request.data.get('landmark')
except APIException:
parameters = [
'store_name', 'phone_number', 'email', 'full_address',
'pin_code', 'landmark(optional)'
]
return response_incomplete_parameters(parameters)
# CHECK IF THE VENDOR HAS ALREADY REQUESTED FOR AN ACCOUNT
existing_vendors = Vendor.objects.filter(phone_number=phone_number)
existing_users = User.objects.filter(username=phone_number)
if len(existing_vendors) > 0 or len(existing_users) > 0:
error_message = 'Vendor with similar details already exists'
return response_error_with_message(error_message)
# CREATING NEW VENDOR
new_vendor = Vendor.objects.create(store_name=store_name,
email=email,
phone_number=phone_number)
new_address = create_address(full_address, pin_code, landmark)
new_vendor.addresses.add(new_address)
new_vendor.save()
# SEND EMAIL TO SALES
try:
approval_link = 'http://app.yourguy.in/#/home/vendor/{}'.format(
new_vendor.id)
subject = 'YourGuy: New Vendor Account Request'
body = constants.VENDOR_ACCOUNT_REQUESTED_MESSAGE_SALES.format(
store_name, phone_number, email, full_address, pin_code,
approval_link)
send_email(constants.SALES_EMAIL, subject, body)
except Exception as e:
pass
success_message = 'Thank you! We have received your request. Our sales team will contact you soon.'
return response_success_with_message(success_message)
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 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 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)
def approve(self, request, pk):
role = user_role(request.user)
vendor = get_object_or_404(Vendor, pk=pk)
notes = request.data.get('notes')
is_retail = request.data.get('is_retail')
industry_ids = request.data.get('industry_ids')
approved_by = request.user
# pricing = request.data.get('pricing')
# pan = request.data.get('pan')
if role == constants.SALES:
try:
username = vendor.phone_number
password = vendor.store_name.replace(" ", "")
password = password.lower()
if is_userexists(username):
user = get_object_or_404(User, username=username)
user.set_password(password)
user.save()
else:
user = User.objects.create_user(username=username,
password=password)
token = create_token(user, constants.VENDOR)
vendor_agent = VendorAgent.objects.create(user=user,
vendor=vendor)
vendor.verified = True
if notes is not None:
vendor.notes = notes
if is_retail is not None:
vendor.is_retail = is_retail
if approved_by is not None:
vendor.approved_by = approved_by
try:
if industry_ids is not None:
for industry_id in industry_ids:
industry = get_object_or_404(Industry,
pk=industry_id)
vendor.industries.add(industry)
except Exception as e:
pass
vendor.save()
except Exception as e:
error_message = 'An error occurred creating the account. Please try again'
return response_error_with_message(error_message)
subject = 'YourGuy: Account created for {}'.format(
vendor.store_name)
customer_message = constants.VENDOR_ACCOUNT_APPROVED_MESSAGE.format(
vendor.phone_number, password)
customer_emails = [vendor.email]
send_email(customer_emails, subject, customer_message)
send_sms(vendor.phone_number, customer_message)
sales_message = constants.VENDOR_ACCOUNT_APPROVED_MESSAGE_SALES.format(
vendor.store_name)
send_email(constants.SALES_EMAIL, subject, sales_message)
success_message = 'Your account credentials has been sent via email and SMS.'
return response_success_with_message(success_message)
else:
return response_access_denied()
