def rm_ctg_fet(request, context=None):
if request.method == 'POST':
try:
fetId = request.POST['feature_id']
clientId = request.session['id']
# Verification
feature = CtgFeature.objects.get(client_id=clientId,
feature_id=fetId,
active=True)
product = CtgProduct.objects.get(product_id=feature.product_id,
active=True)
redir = reverse('go_pr_config') + '?doc_id=' + \
str(product.ctg_doc_id).replace('-', '')
feature.active = False
feature.save()
# Cascade process
removeFeatureCascade(feature.ctg_doc_id)
store_context_in_session(
request, addSnackDataToContext(context, 'Feature removed'))
return redirect(redir)
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
def rm_ctg_spec(request, context=None):
if request.method == 'POST':
try:
flag = request.POST['flag']
specId = request.POST['specification_id']
# Verification
client = UnoClient.objects.get(client_id=request.session['id'])
spec = CtgSpecification.objects.get(specification_id=specId,
active=True)
redir = '?doc_id=' + str(spec.parent_ctg_id).replace('-', '')
if flag == 'PR':
redir = reverse('go_pr_config') + redir
else:
redir = reverse('go_fet_config') + redir
spec.active = False
spec.save()
# Cascade process
removeSpecCascade(spec.specification_id)
store_context_in_session(
request, addSnackDataToContext(context,
'Specification removed'))
return redirect(redir)
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
def rm_site(request, context=None):
if request.method == 'POST':
try:
context = {}
ordMeta = request.session[
'order_meta'] if 'order_meta' in request.session else None
if not ordMeta:
return redirect('go_site_config')
siteId = request.POST['site-id']
site = PtaSite.objects.get(pta_site_id=siteId)
order = site.order_instance
# Delete all products
products = getAllProductsInSite(site)
for product in products:
deleteProductItem(product)
site.delete()
invalidateOrder(order)
refreshOrdSessionData(order, request)
store_context_in_session(
request,
addSnackDataToContext(context, 'Location has been removed'))
return redirect('go_site_config')
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_site_config')
def do_ord_valid(request, context=None):
if request.method == 'POST':
try:
# 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'])
valid = validateOrder(order)
refreshOrdSessionData(order, request)
request.session['ord_valid_count'] = valid
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 find_ord_by_num(request, context=None):
if request.method == 'POST':
try:
ordNumber = request.POST['order-number']
# Check order
order = PtaOrderInstance.objects.get(order_number=ordNumber)
if order.status not in ('IN', 'IP', 'VA', 'FL'):
store_context_in_session(
request,
addSnackDataToContext(context, 'Order cannot be accessed'))
return redirect('go_ord_home')
# Get order data
ordData = generateOrderData(order)
context = {}
context['ordData'] = ordData
return render(request, 'order/index.html', context=context)
except ObjectDoesNotExist:
store_context_in_session(
request, addSnackDataToContext(context, 'Order not found'))
return redirect('go_ord_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unknown Error'))
return redirect('go_ord_home')
else:
return redirect('go_ord_home')
def rm_ctg_val(request, context=None):
if request.method == 'POST':
try:
valueId = request.POST['value_id']
# Verification
client = UnoClient.objects.get(client_id=request.session['id'])
value = CtgValue.objects.get(value_id=valueId)
spec = CtgSpecification.objects.get(
specification_id=value.specification_id, active=True)
redir = reverse('go_spec_config') + '?doc_id=' + \
str(spec.ctg_doc_id).replace('-', '')
value.delete()
store_context_in_session(
request, addSnackDataToContext(context, 'Enumeration removed'))
return redirect(redir)
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
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 find_oppo_by_num(request, context=None):
if request.method == 'POST':
try:
oppoNumber = request.POST['opportunity-number']
opportunity = UnoOpportunity.objects.get(
opportunity_number=oppoNumber)
if not opportunity.active or opportunity.deal_count >= opportunity.deal_limit:
raise AssertionError
# Get client and customer
client = UnoClient.objects.get(client_id=opportunity.client_id)
customer = UnoCustomer.objects.get(
customer_id=opportunity.customer_id)
# Fill opportunity details
oppoData = {}
opportunity.discount_nrc = getGeneralTranslation(
opportunity.discount_nrc)
opportunity.discount_mrc = getGeneralTranslation(
opportunity.discount_mrc)
opportunity.opportunity_number = str(
opportunity.opportunity_number).replace('-', '')
oppoData['opportunity'] = opportunity
oppoData['reDeal'] = int(opportunity.deal_limit) - int(
opportunity.deal_count)
oppoData['clientName'] = client.entity_name
oppoData['clientEml'] = client.contact_email
oppoData['clientPh'] = client.contact_phone
oppoData['clientCty'] = UnoCountry.get_country_by_code(
client.country)
oppoData['custName'] = customer.customer_name
oppoData['custEml'] = customer.contact_email
context = {}
context['oppoData'] = oppoData
return render(request, 'order/index.html', context=context)
except ObjectDoesNotExist:
store_context_in_session(
request, addSnackDataToContext(context,
'Opportunity not found'))
return redirect('go_ord_home')
except AssertionError:
store_context_in_session(
request,
addSnackDataToContext(context, 'Opportunity has expired'))
return redirect('go_ord_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unknown Error'))
return redirect('go_ord_home')
else:
return redirect('go_ord_home')
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 go_site_config(request, context=None):
try:
context = get_context_in_session(request)
if not context:
context = {}
# Get order 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)
context['mapApi'] = getGoogleMapApiSource()
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')
# Load existing sites
siteData = []
sites = getAllSitesInOrder(order)
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'
data['addr'] = ', '.join([doc.address_1, doc.city, doc.country])
data['state'] = doc.state
data['prCount'] = len(getAllProductsInSite(site))
siteData.append(data)
context['siteData'] = siteData
context['siteCount'] = len(siteData)
return render(request, 'order/order-site.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 auth_login(request):
context = {}
if request.method == 'POST':
try:
username = request.POST['username']
password = request.POST['password']
unHash = getSha224Hash(username)
psHash = getSha224Hash(password)
if unHash == getAdminCredentials(
)[0] and psHash == getAdminCredentials()[1]:
request.session['id'] = getCpAdminId()
return redirect('go_admin')
# Get client credentials data
credObj = UnoCredentials.objects.get(username=username)
if credObj and credObj.password_hash == getSha384Hash(
password + credObj.password_salt):
client = UnoClient.objects.get(client_id=credObj.client_id)
if client.active:
request.session['id'] = str(credObj.client_id).replace(
'-', '')
return redirect('go_client')
else:
store_context_in_session(
request, addSnackDataToContext(context,
'Access denied'))
return redirect('go_login')
else:
request.session.clear()
store_context_in_session(
request,
addSnackDataToContext(context, 'Invalid credentials'))
return redirect('go_login')
except ObjectDoesNotExist:
store_context_in_session(
request, addSnackDataToContext(context, 'User not found'))
return redirect('go_login')
except Exception:
# traceback.print_exc()
logError(request)
request.session.clear()
store_context_in_session(request,
addSnackDataToContext(context, 'ERR01'))
return redirect('go_login')
else:
return redirect('go_login')
def create_order(request, context=None):
if request.method == 'POST':
try:
oppoId = request.POST['opportunity-id']
ordName = request.POST['order-name']
ordSecret = request.POST['order-secret']
# Fetch data
opportunity = UnoOpportunity.objects.get(opportunity_id=oppoId)
if not opportunity.active or opportunity.deal_count >= opportunity.deal_limit:
raise AssertionError
client = UnoClient.objects.get(client_id=opportunity.client_id)
customer = UnoCustomer.objects.get(
customer_id=opportunity.customer_id)
# Create basket and order
basket = PtaBasket(client=client, customer=customer)
order = PtaOrderInstance(order_name=ordName,
secret=ordSecret,
client=client,
customer=customer,
opportunity=opportunity,
basket=basket,
status='IN')
basket.save()
order.save()
# Store order in session
meta = generateOrderMeta(order)
save_ord_meta_to_session(request, meta)
return redirect('go_ord_config_home')
except AssertionError:
store_context_in_session(
request,
addSnackDataToContext(context,
'Opportunity invalid or expired'))
return redirect('go_ord_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context,
'Order creation failed'))
return redirect('go_ord_home')
else:
return redirect('go_ord_home')
def go_ord_config_home(request, context=None):
context = get_context_in_session(request)
if not context:
context = {}
# Fill context with order metadata
context = load_ord_meta_to_context(request, context)
if not context:
store_context_in_session(
request, addSnackDataToContext(context, 'Order request failed'))
return redirect('go_ord_home')
order = PtaOrderInstance.objects.get(
order_number=context['ordMeta']['order_number'])
context['numSites'] = len(getAllSitesInOrder(order))
context['numPrs'] = len(getAllProductsInOrder(order))
context['isValid'] = True if order.status in ('VA', 'FL') else False
# Order validation request
if 'ord_valid_count' in request.session:
context['validCnt'] = request.session['ord_valid_count']
del request.session['ord_valid_count']
return render(request, 'order/order-home.html', context=context)
def auth_access_order(request, context=None):
if request.method == 'POST':
try:
ordId = request.POST['order-id']
ordSec = request.POST['order-secret']
order = PtaOrderInstance.objects.get(order_instance_id=ordId)
context = {}
if ordSec == order.secret:
meta = generateOrderMeta(order)
save_ord_meta_to_session(request, meta)
return redirect('go_ord_config_home')
else:
clear_ord_meta(request)
ordData = generateOrderData(order)
context['ordData'] = ordData
context['snack_data'] = 'Invalid secret, access denied'
return render(request, 'order/index.html', context=context)
except Exception:
# traceback.print_exc()
logError(request)
clear_ord_meta(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_ord_home')
def add_ctg_val(request, context=None):
if request.method == 'POST':
try:
specificationId = request.POST['specification_id']
code = request.POST['code']
translation = request.POST['translation']
# Verification
client = UnoClient.objects.get(client_id=request.session['id'])
specification = CtgSpecification.objects.get(
specification_id=specificationId, active=True)
redir = reverse('go_spec_config') + '?doc_id=' + \
str(specification.ctg_doc_id).replace('-', '')
# Validation
if not code or not transaction:
raise AssertionError
value = CtgValue.objects.filter(specification=specification,
code=code)
if value and len(value) > 0:
raise TabError
newValue = CtgValue(specification=specification,
code=code,
translation=translation)
newValue.save()
store_context_in_session(
request, addSnackDataToContext(context, 'Enumeration created'))
return redirect(redir)
except AssertionError:
store_context_in_session(
request, addSnackDataToContext(context, 'Invalid data'))
return redirect(redir)
except TabError:
store_context_in_session(
request, addSnackDataToContext(context, 'Code already exists'))
return redirect(redir)
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
def add_ctg_pr(request, context=None):
if request.method == 'POST':
try:
prCode = request.POST['product_code']
prName = request.POST['product_name']
if not prCode or not prName:
raise AssertionError
if not isValidPrCode(prCode) or len(prName) > 128:
raise AssertionError
client = UnoClient.objects.get(client_id=request.session['id'])
# Get namespaced code and check for duplicate
itemcode = getFullCatalogCode(prCode, client)
tempPr = CtgProduct.objects.filter(itemcode=itemcode)
if tempPr and len(tempPr) > 0:
raise TabError
newProduct = CtgProduct(client=client,
itemcode=itemcode,
name=prName)
newProduct.save()
store_context_in_session(
request, addSnackDataToContext(context, 'Product created'))
return redirect('go_cat_home')
except AssertionError:
store_context_in_session(
request, addSnackDataToContext(context, 'Invalid data'))
return redirect('go_cat_home')
except TabError:
store_context_in_session(
request, addSnackDataToContext(context, 'Code already exists'))
return redirect('go_cat_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
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_site_price(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')
siteIds = request.POST['site_array']
siteList = str(siteIds).split(',') if siteIds else None
sites = []
# Check sites
order = PtaOrderInstance.objects.get(
order_number=ordMeta['order_number'])
if siteList and len(siteList) > 0:
for sid in siteList:
site = PtaSite.objects.get(pta_site_id=sid)
if site.order_instance.order_instance_id == order.order_instance_id:
sites.append(site)
if sites and len(sites) > 0:
for site in sites:
# Do pricing
priceSite(site)
else:
store_context_in_session(
request, addSnackDataToContext(context,
'No site to price'))
return redirect('go_ord_summary')
store_context_in_session(
request, addSnackDataToContext(context, 'Pricing is received'))
return redirect('go_ord_summary')
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 go_ord_summary(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 order.status not in ('VA', 'FL'):
store_context_in_session(
request,
addSnackDataToContext(context, 'Summary is not available'))
return redirect('go_ord_config_home')
# Load product/service tree data
siteDataList = []
sites = PtaSite.objects.filter(
order_instance=order).order_by('creation_time')
if sites and len(sites) > 0:
for site in sites:
populateSiteSummary(siteDataList, site)
context['siteDataList'] = siteDataList
return render(request, 'order/order-summary.html', context=context)
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unknown error'))
return redirect('go_ord_config_home')
def chg_fet(request, context=None):
if request.method == 'POST':
try:
featureId = request.POST['feature_id']
newFetName = request.POST['feature_name']
newLimit = request.POST['limit']
newExt = request.POST['is_extended']
# Verification
clientId = request.session['id']
feature = CtgFeature.objects.filter(client_id=clientId,
feature_id=featureId,
active=True)
if not feature or len(feature) < 1:
raise AssertionError
feature = feature[0]
docId = str(feature.ctg_doc_id).replace('-', '')
redir = reverse('go_fet_config') + '?doc_id=' + docId
feature.name = newFetName
if newLimit and isValidQuantity(newLimit):
feature.limit = newLimit
feature.extended = newExt
feature.save()
store_context_in_session(
request, addSnackDataToContext(context, 'Feature updated'))
return redirect(redir)
except AssertionError:
store_context_in_session(
request,
addSnackDataToContext(context, 'Feature does not exist'))
return redirect('go_cat_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
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 chg_spec(request, context=None):
if request.method == 'POST':
try:
specificationId = request.POST['specification_id']
newLabel = request.POST['spec_label']
newDv = request.POST['default_value']
# Verification
client = UnoClient.objects.get(client_id=request.session['id'])
specification = CtgSpecification.objects.get(
specification_id=specificationId, active=True)
dt = specification.data_type
redir = reverse('go_spec_config') + '?doc_id=' + \
str(specification.ctg_doc_id).replace('-', '')
# Validation
if newLabel and len(newLabel) <= 128:
specification.label = newLabel
if newDv:
if (dt == 'BO' and isValidBoolean(newDv)) or (
dt == 'QTY' and isValidQuantity(newDv)):
specification.default_value = newDv
elif dt == 'STR' or dt == 'ENUM':
specification.default_value = newDv
specification.save()
store_context_in_session(
request, addSnackDataToContext(context,
'Specification updated'))
return redirect(redir)
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
def rm_ctg_pr(request, context=None):
if request.method == 'POST':
try:
productId = request.POST['product_id']
# Client session verification
client = UnoClient.objects.get(client_id=request.session['id'])
# Product verification
product = CtgProduct.objects.filter(client_id=client.client_id,
product_id=productId,
active=True)
if not product or len(product) < 1:
raise AssertionError
product = product[0]
product.active = False
product.save()
# Cascade process
removeProductCascade(product)
store_context_in_session(
request, addSnackDataToContext(context, 'Product removed'))
return redirect('go_cat_home')
except AssertionError:
store_context_in_session(
request,
addSnackDataToContext(context, 'Product does not exist'))
return redirect('go_cat_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
def del_pr_in_site(request, context=None):
if request.method == 'POST':
try:
context = {}
ordMeta = request.session[
'order_meta'] if 'order_meta' in request.session else None
if not ordMeta:
return redirect('go_build_pr')
biId = request.POST['bi_rm_id']
siteId = request.POST['ord_site_id']
site = PtaSite.objects.get(pta_site_id=siteId)
order = site.order_instance
item = PtaBasketItem.objects.get(basket_item_id=biId)
redir = reverse('go_build_pr') + '?site_id=' + \
str(site.pta_site_id).replace('-', '')
# Delete process
deleteProductItem(item)
invalidateSite(site)
invalidateOrder(order)
refreshOrdSessionData(order, request)
store_context_in_session(
request,
addSnackDataToContext(context, 'Product has been deleted'))
return redirect(redir)
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_build_pr')
def go_records(request):
try:
client = UnoClient.objects.get(client_id=request.session['id'])
context = get_context_in_session(request)
if not context:
context = {}
context['entity_name'] = client.entity_name
records = []
oppoList = UnoOpportunity.objects.filter(client=client)
if len(oppoList) < 1:
store_context_in_session(
request, addSnackDataToContext(context,
'No opportunity found'))
return redirect('go_client')
for oppo in oppoList:
customer = UnoCustomer.objects.get(customer_id=oppo.customer_id)
records.append(
(str(oppo.opportunity_number).replace('-', ''),
oppo.creation_time, customer.customer_name, oppo.active))
context['records'] = records
return render(request, 'core/records.html', context=context)
except Exception:
# traceback.print_exc()
logError(request)
if request and hasattr(request, 'session'):
request.session.clear()
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected Error'))
return redirect('go_login')
def chg_pr_name(request, context=None):
if request.method == 'POST':
try:
productId = request.POST['product_id']
newPrName = request.POST['product_name']
# Verification
clientId = request.session['id']
product = CtgProduct.objects.filter(client_id=clientId,
product_id=productId,
active=True)
if not product or len(product) < 1:
raise AssertionError
product = product[0]
product.name = newPrName
docId = str(product.ctg_doc_id).replace('-', '')
redir = reverse('go_pr_config') + '?doc_id=' + docId
product.save()
store_context_in_session(
request, addSnackDataToContext(context, 'Product updated'))
return redirect(redir)
except AssertionError:
store_context_in_session(
request,
addSnackDataToContext(context, 'Product does not exist'))
return redirect('go_cat_home')
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Unexpected error'))
return redirect('go_cat_home')
else:
return redirect('go_cat_home')
def go_cat_home(request, context=None):
try:
context = get_context_in_session(request)
if not context:
context = {}
ITEMS_PER_PAGE = 10
productPage = None
if request.GET.get('pr_page'):
productPage = request.GET.get('pr_page')
else:
productPage = 1
client = UnoClient.objects.get(client_id=request.session['id'])
context['client'] = client
context['addPrForm'] = AddPrForm()
# Get all products
prResult = CtgProduct.objects.filter(client_id=client.client_id,
active=True).order_by(
'-creation_time', 'itemcode')
pagedList = Paginator(prResult, ITEMS_PER_PAGE)
products = pagedList.get_page(productPage)
for pr in products:
pr.product_id = str(pr.product_id).replace('-', '')
pr.itemcode = getDefCatalogCode(pr.itemcode)
context['products'] = products
context['prCount'] = len(products)
return render(request, 'catalog/index.html', context=context)
except Exception:
# traceback.print_exc()
logError(request)
if request and hasattr(request, 'session'):
request.session.clear()
store_context_in_session(
request, addSnackDataToContext(context, 'Unknown Error'))
return redirect('go_login')
def add_pr_to_basket(request, context=None):
if request.method == 'POST':
try:
context = {}
ordMeta = request.session[
'order_meta'] if 'order_meta' in request.session else None
if not ordMeta:
return redirect('go_build_pr')
prData = parseJson(request.POST['ctg_add_data'])
siteId = request.POST['ord_site_id']
# Get order details
order = PtaOrderInstance.objects.get(
order_number=ordMeta['order_number'])
site = PtaSite.objects.get(pta_site_id=siteId)
redir = reverse('go_build_pr') + '?site_id=' + \
str(site.pta_site_id).replace('-', '')
leadSerial = getLeadSerialInOrderSite(order, site)
tempSerial = leadSerial
if not prData or not leadSerial:
store_context_in_session(
request,
addSnackDataToContext(context, 'Invalid order data'))
return redirect(redir)
# Add products to basket
for ctgId, count in prData.items():
tempSerial = addNewProductsToSite(order, site, ctgId, count,
tempSerial)
invalidateSite(site)
invalidateOrder(order)
refreshOrdSessionData(order, request)
if tempSerial > leadSerial:
diff = tempSerial - leadSerial
if diff == 1:
store_context_in_session(
request,
addSnackDataToContext(context,
'1 product has been added'))
else:
store_context_in_session(
request,
addSnackDataToContext(
context,
str(diff) + ' products have been added'))
else:
store_context_in_session(
request,
addSnackDataToContext(context, 'No product is added'))
return redirect(redir)
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_build_pr')
def save_svc_config(request, context=None):
if request.method == 'POST':
try:
context = {}
ordMeta = request.session[
'order_meta'] if 'order_meta' in request.session else None
if not ordMeta:
return redirect('go_svc_config')
svcDataStruct = parseJson(request.POST['svc_json'])
svcId = svcDataStruct['svcId']
pspList = svcDataStruct['pspList']
fetList = svcDataStruct['fetList']
# Check order
order = PtaOrderInstance.objects.get(
order_number=ordMeta['order_number'])
basket = order.basket
productItem = PtaBasketItem.objects.get(basket_item_id=svcId)
site = productItem.pta_site
redir = reverse('go_svc_config') + '?svc_id=' + \
str(svcId).replace('-', '')
if isOrderLocked(order):
store_context_in_session(
request, addSnackDataToContext(context, 'Order is locked'))
return redirect('go_ord_config_home')
# Save product level specs
saveBaseSpec(productItem)
for psp in pspList:
createOrUpdateSpec(psp['id'], productItem, psp['value'])
# Save features
for fet in fetList:
if fet['addFlag']:
featureItem = createOrGetFeature(fet['id'], productItem)
# Save feature level specs
saveBaseSpec(featureItem)
for fsp in fet['fspList']:
createOrUpdateSpec(fsp['id'], featureItem,
fsp['value'])
else:
existFeature = getExistingFeature(productItem, fet['id'])
if existFeature:
deleteFeatureItem(existFeature)
clearSitePrice(site)
# Validation
valid = True
errorList = []
valid = validateProductItem(productItem, errorList)
saveErrorInMap(request, str(productItem.basket_item_id), errorList)
if valid:
store_context_in_session(
request,
addSnackDataToContext(context, 'Configuration is saved'))
else:
invalidateSite(site)
invalidateOrder(order)
refreshOrdSessionData(order, request)
store_context_in_session(
request,
addSnackDataToContext(context,
'Error(s) detected in service'))
return redirect(redir)
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_svc_config')
def go_svc_config(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)
serviceList = []
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')
# Get all sites and products
sites = PtaSite.objects.filter(
order_instance=order).order_by('site_name')
if not sites or len(sites) < 1:
store_context_in_session(
request, addSnackDataToContext(context, 'No sites found'))
return redirect('go_ord_config_home')
else:
for site in sites:
products = PtaBasketItem.objects.filter(
pta_site=site, parent_id=None).order_by('serial')
if products and len(products) > 0:
for pr in products:
serviceList.append(
str(pr.basket_item_id).replace('-', ''))
if len(serviceList) < 1:
store_context_in_session(
request, addSnackDataToContext(context, 'No services found'))
return redirect('go_ord_config_home')
serviceId = request.GET.get('svc_id') if request.GET.get(
'svc_id') else serviceList[0]
if serviceId not in serviceList:
store_context_in_session(
request, addSnackDataToContext(context, 'Invalid service'))
return redirect('go_ord_config_home')
preSvcId = None
nxtSvcId = None
if serviceList.index(serviceId) > 0:
preSvcId = serviceList[serviceList.index(serviceId) - 1]
if serviceList.index(serviceId) < len(serviceList) - 1:
nxtSvcId = serviceList[serviceList.index(serviceId) + 1]
context['preId'] = preSvcId
context['nxtId'] = nxtSvcId
service = PtaBasketItem.objects.get(basket_item_id=serviceId)
siteDoc = service.pta_site
addrDoc = siteDoc.site
svcData = {}
svcData['id'] = str(service.basket_item_id)
svcData['name'] = getBasketItemName(service)
svcData['serial'] = zeroPrepender(service.serial, 5)
svcData['valid'] = '1' if service.is_valid else '0'
context['siteDoc'] = siteDoc
context['addrDoc'] = addrDoc
context['svcData'] = svcData
svcBasketDoc = populateServiceDoc(service)
# Load catalog definitions
# Product level
prSpecList = []
prCtg = CtgProduct.objects.get(ctg_doc_id=service.ctg_doc_id)
prSpecs = CtgSpecification.objects.filter(
parent_ctg_id=service.ctg_doc_id, active=1)
pspCnt = 0
for psp in prSpecs:
val = getLeafValueFromSvcDoc(svcBasketDoc, service.itemcode,
psp.leaf_name)
if psp.leaf_name == 'SP_BASE':
prSpecList.insert(0, buildSpecInfo(psp, val))
else:
prSpecList.append(buildSpecInfo(psp, val))
pspCnt += 1
# Feature level
prFetList = []
fetCtg = CtgFeature.objects.filter(product=prCtg,
active=1).order_by('creation_time')
fspCnt = 0
for fet in fetCtg:
fetDoc = {}
fetDoc['id'] = str(fet.ctg_doc_id)
fetDoc['itemcode'] = fet.itemcode
fetDoc['name'] = fet.name
fetSpList = []
fetSpecs = CtgSpecification.objects.filter(
parent_ctg_id=fet.ctg_doc_id, active=1)
for fsp in fetSpecs:
val = getLeafValueFromSvcDoc(svcBasketDoc, fet.itemcode,
fsp.leaf_name)
if fsp.leaf_name == 'SP_BASE':
fetSpList.insert(0, buildSpecInfo(fsp, val))
else:
fetSpList.append(buildSpecInfo(fsp, val))
fspCnt += 1
fetDoc['specs'] = fetSpList
prFetList.append(fetDoc)
context['prCtgData'] = prSpecList
context['pspCnt'] = pspCnt
context['fetCtgData'] = prFetList
context['fspCnt'] = fspCnt
# Populate error
errorList = getOrCreateSvcError(request, str(service.basket_item_id))
context['errList'] = errorList
context['errLen'] = len(errorList)
return render(request, 'order/order-service.html', context=context)
except Exception:
# traceback.print_exc()
logError(request)
store_context_in_session(
request, addSnackDataToContext(context, 'Redirect error'))
return redirect('go_ord_config_home')
