def update(request, pk):
template_url = 'order-items/update.html'
operator = Operators.login_required(request)
if operator is None:
Operators.set_redirect_field_name(request, request.path)
return redirect(reverse("operators_signin"))
else:
auth_permissions = Operators.get_auth_permissions(operator)
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values(
):
# try:
model = Order_Items.objects.get(order_item_id=pk)
order = Orders.objects.get(order_id=model.orders_order_id)
if request.method == 'POST':
form = OrderItemUpdateForm(request.POST)
# noinspection PyArgumentList
if form.is_valid():
title = 'unknown'
type = form.cleaned_data['type']
model.order_item_type_id = 0
if type == 'service':
title = form.cleaned_data['title_service']
if type == 'goods':
type_id = form.cleaned_data['title_goods']
model.order_item_type_id = type_id
product = Products.objects.get(product_id=type_id)
title = product.product_title
if type == 'asset':
type_id = form.cleaned_data['title_asset']
model.order_item_type_id = type_id
product = Products.objects.get(product_id=type_id)
title = product.product_title
model.order_item_type = type
model.order_item_title = title
model.order_item_sub_title = ''
model.order_item_quantity_ordered = form.cleaned_data[
'quantity_ordered']
model.order_item_quantity_unit = form.cleaned_data[
'quantity_unit']
model.order_item_unit_price = form.cleaned_data[
'unit_price']
model.order_item_total_price = model.order_item_quantity_ordered * model.order_item_unit_price
model.order_item_updated_at = Utils.get_current_datetime_utc(
)
model.order_item_updated_id = operator.operator_id
model.order_item_updated_by = operator.operator_name
model.order_item_updated_department = operator.operator_department
model.order_item_updated_role = operator.operator_role
model.save()
Orders.update_grand_total(request, order, operator)
messages.success(request, 'Item updated successfully.')
return redirect(
reverse("orders_view", args=[order.order_id]))
else:
error_string = ' '.join([
' '.join(x for x in l)
for l in list(form.errors.values())
])
messages.error(request, '' + error_string)
return redirect(reverse("orders_view", args=[order_id]))
else:
title = 'unknown'
type = model.order_item_type
if type == 'service':
title = model.order_item_title
if type == 'goods':
title = model.order_item_type_id
if type == 'asset':
title = model.order_item_type_id
form = OrderItemUpdateForm(
initial={
'order_id': order.order_code,
'type': type,
'title_service': title,
'title_goods': title,
'title_asset': title,
'duration': model.order_item_duration,
'unit_price': model.order_item_unit_price,
'currency': model.order_item_currency,
'quantity_ordered': model.order_item_quantity_ordered,
'quantity_unit': model.order_item_quantity_unit,
})
return render(
request, template_url, {
'section':
settings.BACKEND_SECTION_PROCUREMENT_ALL_REQUESTS,
'title': Order_Items.TITLE,
'name': Order_Items.NAME,
'operator': operator,
'auth_permissions': auth_permissions,
'form': form,
'model': model,
})
# except(TypeError, ValueError, OverflowError, Orders.DoesNotExist, Order_Items.DoesNotExist):
# return HttpResponseNotFound('Not Found', content_type='text/plain')
else:
return HttpResponseForbidden('Forbidden',
content_type='text/plain')
def select_multiple(request):
if request.is_ajax():
operator = Operators.login_required(request)
if operator is None:
# Operators.set_redirect_field_name(request, request.path)
# return redirect(reverse("operators_signin"))
return HttpResponse('signin', content_type='text/plain')
else:
auth_permissions = Operators.get_auth_permissions(operator)
action = request.POST['action']
ids = request.POST['ids']
try:
ids = ids.split(",")
except (TypeError, ValueError, OverflowError):
ids = None
if action != '' and ids is not None:
if action == 'usaid-approve-yes':
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values(
):
for id in ids:
try:
model = Order_Items.objects.get(
order_item_id=id)
model.order_item_usaid_approval = True
model.save()
except (TypeError, ValueError, OverflowError,
Order_Items.DoesNotExist):
continue
messages.success(request, 'Updated successfully.')
else:
return HttpResponseForbidden('Forbidden',
content_type='text/plain')
if action == 'usaid-approve-no':
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values(
):
for id in ids:
try:
model = Order_Items.objects.get(
order_item_id=id)
model.order_item_usaid_approval = False
model.save()
except (TypeError, ValueError, OverflowError,
Order_Items.DoesNotExist):
continue
messages.success(request, 'Updated successfully.')
else:
return HttpResponseForbidden('Forbidden',
content_type='text/plain')
if action == 'order-item-received':
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values(
):
for id in ids:
try:
model = Order_Items.objects.get(
order_item_id=id)
if model.order_item_status == Order_Items.STATUS_PENDING:
if model.order_item_type == Order_Items.TYPE_SERVICE:
model.order_item_received_at = Utils.get_current_datetime_utc(
)
model.order_item_received_id = operator.operator_id
model.order_item_received_by = operator.operator_name
model.order_item_received_department = operator.operator_department
model.order_item_received_role = operator.operator_role
model.order_item_status = Order_Items.STATUS_RECEIVED
model.save()
except (TypeError, ValueError, OverflowError,
Order_Items.DoesNotExist):
continue
messages.success(request, 'Updated successfully.')
else:
return HttpResponseForbidden('Forbidden',
content_type='text/plain')
if action == 'order-item-pending':
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values(
):
for id in ids:
try:
model = Order_Items.objects.get(
order_item_id=id)
if model.order_item_status == Order_Items.STATUS_RECEIVED:
if model.order_item_type != Order_Items.TYPE_SERVICE:
try:
order = Orders.objects.get(
order_id=model.orders_order_id)
inventory = Inventory.objects.get(
inventory_order_purchase_no=
order.order_purchase_no)
inventory_items = Inventory_Items.objects.filter(
inventory_inventory_id=inventory
.inventory_id)
for inventory_item in inventory_items:
try:
product = Products.objects.get(
product_id=inventory_item
.products_product_id)
product.product_quantity_available = product.product_quantity_available - inventory_item.inventory_item_product_quantity_ordered
product.product_updated_at = Utils.get_current_datetime_utc(
)
product.product_updated_id = operator.operator_id
product.product_updated_by = operator.operator_name
product.product_updated_department = operator.operator_department
product.product_updated_role = operator.operator_role
product.save()
inventory_item.delete()
except Products.DoesNotExist:
inventory_item.delete()
continue
except (Orders.DoesNotExist,
Inventory.DoesNotExist):
print(
'Order or inventory does not exist.'
)
model.order_item_received_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE
model.order_item_received_id = ''
model.order_item_received_by = ''
model.order_item_received_department = ''
model.order_item_received_role = ''
model.order_item_status = Order_Items.STATUS_PENDING
model.save()
except (TypeError, ValueError, OverflowError,
Order_Items.DoesNotExist):
continue
messages.success(request, 'Updated successfully.')
else:
return HttpResponseForbidden('Forbidden',
content_type='text/plain')
return HttpResponse('success', content_type='text/plain')
else:
return HttpResponseBadRequest('Bad Request',
content_type='text/plain')
else:
return HttpResponseForbidden('Forbidden', content_type='text/plain')
def create(request, pk, action, ids):
template_url = 'inventory-items/create.html'
operator = Operators.login_required(request)
if operator is None:
Operators.set_redirect_field_name(request, request.path)
return redirect(reverse("operators_signin"))
else:
auth_permissions = Operators.get_auth_permissions(operator)
if settings.ACCESS_PERMISSION_ORDER_UPDATE in auth_permissions.values(
):
# try:
order = Orders.objects.get(order_id=pk)
order_proposal = Order_Proposals.objects.get(
order_proposal_id=order.order_proposal_id)
try:
ids = ids.split("-")
except (TypeError, ValueError, OverflowError):
ids = None
if action != 'order-item-received' or ids is None:
return HttpResponseNotFound('Not Found',
content_type='text/plain')
else:
if request.method == 'POST':
form = InventoryItemCreateForm(request.POST)
# noinspection PyArgumentList
if form.is_valid():
inventory_item_voucher_reference = form.cleaned_data[
'inventory_item_voucher_reference']
inventory_item_location = form.cleaned_data[
'inventory_item_location']
inventory_item_equipment_holder_status = form.cleaned_data[
'inventory_item_equipment_holder_status']
inventory_item_staff_name = form.cleaned_data[
'inventory_item_staff_name']
inventory_item_room_number = form.cleaned_data[
'inventory_item_room_number']
inventory_item_disposal_date = form.cleaned_data[
'inventory_item_disposal_date']
inventory_item_verified_date = form.cleaned_data[
'inventory_item_verified_date']
inventory_item_present_condition = form.cleaned_data[
'inventory_item_present_condition']
inventory_item_remark = form.cleaned_data[
'inventory_item_remark']
try:
inventory = Inventory.objects.get(
inventory_order_purchase_no=order.
order_purchase_no)
inventory.inventory_order_proposal_id = order.order_proposal_id
inventory.inventory_order_proposal_supplier_title = order_proposal.order_proposal_supplier_title
inventory.inventory_updated_at = Utils.get_current_datetime_utc(
)
inventory.inventory_updated_id = operator.operator_id
inventory.inventory_updated_by = operator.operator_name
inventory.inventory_updated_department = operator.operator_department
inventory.inventory_updated_role = operator.operator_role
inventory.save()
except Inventory.DoesNotExist:
inventory = Inventory()
inventory.inventory_order_purchase_no = order.order_purchase_no
inventory.inventory_order_proposal_id = order.order_proposal_id
inventory.inventory_order_proposal_supplier_title = order_proposal.order_proposal_supplier_title
inventory.inventory_created_at = Utils.get_current_datetime_utc(
)
inventory.inventory_created_id = operator.operator_id
inventory.inventory_created_by = operator.operator_name
inventory.inventory_created_department = operator.operator_department
inventory.inventory_created_role = operator.operator_role
inventory.inventory_updated_at = Utils.get_current_datetime_utc(
)
inventory.inventory_updated_id = operator.operator_id
inventory.inventory_updated_by = operator.operator_name
inventory.inventory_updated_department = operator.operator_department
inventory.inventory_updated_role = operator.operator_role
inventory.save()
for id in ids:
try:
order_item = Order_Items.objects.get(
order_item_id=id)
if order_item.order_item_status == Order_Items.STATUS_PENDING:
if order_item.order_item_type != Order_Items.TYPE_SERVICE:
order_item.order_item_received_at = Utils.get_current_datetime_utc(
)
order_item.order_item_received_id = operator.operator_id
order_item.order_item_received_by = operator.operator_name
order_item.order_item_received_department = operator.operator_department
order_item.order_item_received_role = operator.operator_role
order_item.order_item_status = Order_Items.STATUS_RECEIVED
order_item.save()
try:
product = Products.objects.get(
product_id=order_item.
order_item_type_id)
inventory_item = Inventory_Items()
inventory_item.inventory_inventory_id = inventory.inventory_id
inventory_item.products_product_id = order_item.order_item_type_id
inventory_item.inventory_item_product_type = order_item.order_item_type
inventory_item.inventory_item_product_code = product.product_code
inventory_item.inventory_item_product_tag = product.product_tag
inventory_item.inventory_item_product_category = product.product_category
inventory_item.inventory_item_product_title = product.product_title
inventory_item.inventory_item_product_sub_title = product.product_sub_title
inventory_item.inventory_item_product_quantity_initial = product.product_quantity_available
inventory_item.inventory_item_product_quantity_ordered = order_item.order_item_quantity_ordered
inventory_item.inventory_item_product_quantity_balance = product.product_quantity_available + order_item.order_item_quantity_ordered
inventory_item.inventory_item_product_quantity_unit = product.product_quantity_unit
inventory_item.inventory_item_product_currency = order_item.order_item_currency
inventory_item.inventory_item_product_unit_price = order_item.order_item_unit_price
inventory_item.inventory_item_product_rate_price = 0
inventory_item.inventory_item_product_usd_price = 0
inventory_item.inventory_item_product_usaid_equipment_price = 0
inventory_item.inventory_item_product_small_equipment_price = 0
inventory_item.inventory_item_project = order.order_project_name
inventory_item.inventory_item_voucher_reference = inventory_item_voucher_reference
inventory_item.inventory_item_location = inventory_item_location
inventory_item.inventory_item_equipment_holder_status = inventory_item_equipment_holder_status
inventory_item.inventory_item_staff_name = inventory_item_staff_name
inventory_item.inventory_item_room_number = inventory_item_room_number
inventory_item.inventory_item_present_condition = inventory_item_present_condition
inventory_item.inventory_item_disposal_date = inventory_item_disposal_date
inventory_item.inventory_item_verified_date = inventory_item_verified_date
inventory_item.inventory_item_remark = inventory_item_remark
inventory_item.inventory_created_at = Utils.get_current_datetime_utc(
)
inventory_item.inventory_created_id = operator.operator_id
inventory_item.inventory_created_by = operator.operator_name
inventory_item.inventory_created_department = operator.operator_department
inventory_item.inventory_created_role = operator.operator_role
inventory_item.inventory_updated_at = Utils.get_current_datetime_utc(
)
inventory_item.inventory_updated_id = operator.operator_id
inventory_item.inventory_updated_by = operator.operator_name
inventory_item.inventory_updated_department = operator.operator_department
inventory_item.inventory_updated_role = operator.operator_role
inventory_item.save()
product.product_quantity_available = product.product_quantity_available + order_item.order_item_quantity_ordered
product.product_updated_at = Utils.get_current_datetime_utc(
)
product.product_updated_id = operator.operator_id
product.product_updated_by = operator.operator_name
product.product_updated_department = operator.operator_department
product.product_updated_role = operator.operator_role
product.save()
except Products.DoesNotExist:
continue
except Order_Items.DoesNotExist:
continue
messages.success(request, 'Updated successfully.')
return redirect(
reverse("order_items_index",
args=[order.order_id]))
else:
error_string = ' '.join([
' '.join(x for x in l)
for l in list(form.errors.values())
])
messages.error(request, '' + error_string)
return redirect(
reverse("order_items_index",
args=[order.order_id]))
else:
form = InventoryItemCreateForm(
initial={
'inventory_order_purchase_no':
order.order_purchase_no,
'inventory_order_project_name':
order.order_project_name,
})
return render(
request, template_url, {
'section':
settings.BACKEND_SECTION_PROCUREMENT_ALL_REQUESTS,
'title': Orders.TITLE,
'name': Orders.NAME,
'operator': operator,
'auth_permissions': auth_permissions,
'form': form,
})
# except(TypeError, ValueError, OverflowError, Orders.DoesNotExist, Order_Proposals.DoesNotExist,
# Order_Proposals.DoesNotExist):
# return HttpResponseNotFound('Not Found', content_type='text/plain')
else:
return HttpResponseForbidden('Forbidden',
content_type='text/plain')
