def do_enroll(request):
if request and request.method == 'POST':
try:
context = {}
# Verify client
client = None
if request.session:
client = UnoClient.objects.get(client_id=request.session['id'])
if not client:
raise RuntimeError
# Retrieve form values
customer_name = request.POST['customer_name']
contact_email = request.POST['contact_email']
country = request.POST['country']
if customer_name and contact_email and country:
newCustomer = UnoCustomer(client=client,
customer_name=customer_name,
contact_email=contact_email,
country=country)
newCustomer.save()
return go_success(
HttpRequest(), {
'message': get_app_message('enroll_success'),
'return_link': reverse('go_client')
})
else:
store_context_in_session(
request, addSnackDataToContext(context,
'Invalid form data'))
return redirect('go_login')
except RuntimeError:
if hasattr(request, 'session') and request.session:
request.session.clear()
store_context_in_session(
request,
addSnackDataToContext(context, 'Invalid client session'))
return redirect('go_login')
except Exception:
# traceback.print_exc()
logError(request)
return go_error(
HttpRequest(), {
'error': get_app_message('enroll_error'),
'message': get_app_message('enroll_error_message')
})
else:
return redirect('go_client')
def do_ord_submit(request, context=None):
if request.method == 'POST':
try:
ordMeta = request.session[
'order_meta'] if 'order_meta' in request.session else None
if not ordMeta:
return redirect('go_ord_summary')
order = PtaOrderInstance.objects.get(
order_number=ordMeta['order_number'])
# Validation
if order.status == 'VA':
order.status = 'FL'
basket = order.basket
basket.is_locked = True
# Send external request here
# No code is provided due to the nature of this project
# Archive record
oldAr = UnoOrder.objects.filter(
order_number=order.order_number)
if not oldAr or len(oldAr) < 1:
arOrder = UnoOrder(order_number=order.order_number,
client=order.client,
customer=order.customer,
opportunity=order.opportunity,
status='SM')
arOrder.save()
# Increase deal count
oppo = order.opportunity
oppo.deal_count += 1
oppo.save()
basket.save()
order.save()
clear_ord_meta(request)
return go_success(
HttpRequest(),
{'message': get_app_message('order_submit_message')})
else:
store_context_in_session(
request,
addSnackDataToContext(context, 'Cannot submit this order'))
return redirect('go_ord_config_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unknown error'))
return redirect('go_ord_config_home')
else:
return redirect('go_ord_summary')
def can_oppo(request, context=None):
if request and request.method == 'POST':
try:
if not context:
context = {}
client = None
if request.session:
client = UnoClient.objects.get(client_id=request.session['id'])
if not client:
raise RuntimeError
opportunity = UnoOpportunity.objects.get(
opportunity_number=request.POST['oppoNb'])
if not opportunity.active:
raise Exception
opportunity.active = False
opportunity.save()
store_context_in_session(
request, addSnackDataToContext(context,
'Opportunity annulled'))
return redirect('go_records')
except RuntimeError:
if hasattr(request, 'session') and request.session:
request.session.clear()
store_context_in_session(
request,
addSnackDataToContext(context, 'Invalid client session'))
return redirect('go_login')
except Exception:
# traceback.print_exc()
logError(request)
return go_error(
HttpRequest(), {
'error': get_app_message('oppo_can_error'),
'message': get_app_message('oppo_can_message')
})
else:
return redirect('go_records')
def do_ord_cancel(request, context=None):
if request.method == 'POST':
try:
ordMeta = request.session[
'order_meta'] if 'order_meta' in request.session else None
if not ordMeta:
store_context_in_session(
request,
addSnackDataToContext(context, 'Order request failed'))
return redirect('go_ord_home')
order = PtaOrderInstance.objects.get(
order_number=ordMeta['order_number'])
if order.status in ('IN', 'IP', 'VA'):
order.status = 'VD'
basket = order.basket
basket.is_locked = True
basket.save()
order.save()
clear_ord_meta(request)
return go_success(
HttpRequest(),
{'message': get_app_message('order_cancel_message')})
else:
store_context_in_session(
request,
addSnackDataToContext(context,
'Invalid cancellation request'))
return redirect('go_ord_config_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unknown error'))
return redirect('go_ord_config_home')
else:
return redirect('go_ord_config_home')
def go_build_pr(request, context=None):
try:
context = get_context_in_session(request)
if not context:
context = {}
# Metadata
ordMeta = request.session[
'order_meta'] if 'order_meta' in request.session else None
if not ordMeta:
store_context_in_session(
request, addSnackDataToContext(context,
'Order request failed'))
return redirect('go_ord_home')
else:
context = load_ord_meta_to_context(request, context)
order = PtaOrderInstance.objects.get(
order_number=ordMeta['order_number'])
if isOrderLocked(order):
store_context_in_session(
request, addSnackDataToContext(context, 'Order is locked'))
return redirect('go_ord_config_home')
client = order.client
# Load catalog products
ctgList = getAllClientProducts(client)
ctgData = []
if not ctgList or len(ctgList) == 0:
return go_error(
HttpRequest(), {
'error': get_app_message('catalog_error'),
'message': get_app_message('catalog_error_message')
})
for pr in ctgList:
prDoc = {}
prDoc['id'] = str(pr.ctg_doc_id)
prDoc['code'] = getDefCatalogCode(pr.itemcode)
prDoc['name'] = pr.name
ctgData.append(prDoc)
context['prData'] = ctgData
# Load Sites
sites = getAllSitesInOrder(order)
if len(sites) == 0:
store_context_in_session(
request, addSnackDataToContext(context, 'No sites found'))
return redirect('go_site_config')
siteData = []
for site in sites:
data = {}
doc = site.site
data['id'] = str(site.pta_site_id)
data['name'] = site.site_name
data['valid'] = '1' if site.is_valid else '0'
siteData.append(data)
context['siteData'] = siteData
# Load current site and products
site = sites[0]
siteId = request.GET.get('site_id')
if siteId:
sites = sites.filter(pta_site_id=siteId)
if len(sites) > 0:
site = sites[0]
else:
store_context_in_session(
request,
addSnackDataToContext(context, 'Requested site not found'))
return redirect('go_site_config')
siteDoc = site.site
context['selId'] = str(site.pta_site_id)
context['siteDoc'] = siteDoc
products = getAllProductsInSite(site)
biData = []
for bi in products:
biDoc = {}
biDoc['id'] = str(bi.basket_item_id)
biDoc['name'] = getBasketItemName(bi)
biDoc['serial'] = zeroPrepender(bi.serial, 5)
biDoc['valid'] = '1' if bi.is_valid else '0'
biData.append(biDoc)
context['biData'] = biData
context['prCount'] = len(biData)
return render(request, 'order/order-product.html', context=context)
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Redirect error'))
return redirect('go_ord_home')
def do_oppo(request, context=None):
if request and request.method == 'POST':
try:
if not context:
context = {}
client = None
if request.session:
client = UnoClient.objects.get(client_id=request.session['id'])
if not client:
raise RuntimeError
# Get opportunity details
customer_id = request.POST['customer']
discount_nrc = request.POST['discount_nrc']
discount_mrc = request.POST['discount_mrc']
deal_limit = int(request.POST['deal_limit'])
if deal_limit < 1 or deal_limit > 32:
raise AssertionError
customer_id = str(customer_id).replace('-', '')
customer = UnoCustomer.objects.get(customer_id=customer_id)
newOpportunity = UnoOpportunity(client=client,
customer=customer,
discount_nrc=discount_nrc,
discount_mrc=discount_mrc,
deal_limit=deal_limit)
newOpportunity.save()
return go_success(
HttpRequest(), {
'message': getNewOppoMessage(
newOpportunity.opportunity_number),
'return_link': reverse('go_client')
})
except AssertionError:
store_context_in_session(
request,
addSnackDataToContext(context, 'Invalid data encountered'))
return redirect('go_client')
except RuntimeError:
if hasattr(request, 'session') and request.session:
request.session.clear()
store_context_in_session(
request,
addSnackDataToContext(context, 'Invalid client session'))
return redirect('go_login')
except Exception:
# traceback.print_exc()
logError(request)
return go_error(
HttpRequest(), {
'error': get_app_message('oppo_error'),
'message': get_app_message('oppo_error_message')
})
else:
return redirect('go_client')
def do_approve(request):
if request.method == 'POST':
try:
if request.session['id'] != getCpAdminId():
request.session.clear()
return redirect('go_login')
# Retrieve form data
client_id = request.POST['client_id']
ctg_name = request.POST['ctg_name']
action = request.POST['action']
comment = request.POST['message']
# Get client data
client = UnoClient.objects.get(client_id=client_id)
# Validate action
valid = False
tempStatus = ''
if client.status == getClientStates('PE'):
if action == 'AP' and ctg_name:
valid = True
tempStatus = getClientStates('AP')
elif action == 'DE':
valid = True
tempStatus = getClientStates('DE')
elif client.status == getClientStates('AP'):
if action == 'RV':
valid = True
tempStatus = getClientStates('RV')
elif client.status == getClientStates('RV'):
if action == 'RI':
valid = True
tempStatus = getClientStates('AP')
else:
valid = False
if not valid:
raise RuntimeError
# Create approval data
newApproval = UnoApproval(client=client,
action=action,
message=comment)
newApproval.save()
# Update client data
if (tempStatus == getClientStates('AP')):
client.active = 1
client.ctg_name = ctg_name
else:
client.active = 0
client.status = tempStatus
client.save()
# Retrieve the current page
redirectPage = 1
if 'admin_page' in request.session:
redirectPage = request.session['admin_page']
# Success message
store_context_in_session(
request,
addSnackDataToContext({}, 'Your action has been applied'))
return redirect(
reverse('go_admin') + '?request_page=' + str(redirectPage))
except Exception:
# traceback.print_exc()
logError(request)
return go_error(
HttpRequest(), {
'error': get_app_message('approval_error'),
'message': get_app_message('approval_error_message')
})
else:
return redirect('go_admin')
def do_register(request):
if request.method == 'POST':
registerForm = RegisterForm(request.POST, request.FILES)
# Basic validation
if registerForm.is_multipart() and registerForm.is_valid():
# Specific validation
if isValidRegisterRequest(request.POST):
entity_name = request.POST['entity_name']
country = request.POST['country']
trade_ticker = request.POST['trade_ticker']
contact_email = request.POST['contact_email']
contact_phone = request.POST['contact_phone']
summary = request.POST['summary']
website = request.POST['website']
username = request.POST['username']
password = request.POST['password']
recovery_email = request.POST['recovery_email']
pin = request.POST['pin']
# Obtain binary data (deprecated but doable)
sl_bin = b''
try:
signature_letter = request.FILES['signature_letter']
for chunk in signature_letter.chunks():
sl_bin += chunk
except KeyError:
sl_bin = b''
pass
password_salt = getRandomSalt(8)
if len(trade_ticker) == 0:
trade_ticker = None
if len(summary) == 0:
summary = None
if len(website) == 0:
website = None
try:
# Create client object
newClient = UnoClient(ctg_name=None,
entity_name=entity_name,
country=country,
trade_ticker=trade_ticker,
contact_email=contact_email,
contact_phone=contact_phone,
signature_letter=sl_bin,
summary=summary,
website=website)
# Create credentials object
newCredentials = UnoCredentials(
client=newClient,
username=username,
password_salt=password_salt,
password_hash=getSha384Hash(password + password_salt),
recovery_email=recovery_email,
pin=pin)
newClient.save()
newCredentials.save()
except Exception:
# traceback.print_exc()
logError(request)
return go_error(
HttpRequest(), {
'error': get_app_message('register_error'),
'message':
get_app_message('register_error_message')
})
return go_success(
HttpRequest(),
{'message': get_app_message('register_success')})
else:
return go_error(
HttpRequest(), {
'error': get_app_message('register_error'),
'message': get_app_message('register_error_message')
})
else:
return go_error(
HttpRequest(), {
'error': get_app_message('register_error'),
'message': get_app_message('register_error_message')
})
else:
return redirect('go_register')