def json_notifications(request): 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) objects = Notifications.objects.filter(notification_to_id=operator.operator_id) return HttpResponse(serializers.serialize("json", objects), content_type="application/json")
def temp_upload(request): operator = Operators.login_required(request) if operator is None: Operators.set_redirect_field_name(request, request.path) return redirect(reverse("operators_signin")) else: if request.POST: file_path = settings.MEDIA_ROOT + '/temp/' + request.POST['name'] image_data = request.POST['data'] Utils.save_image_base64(image_data, file_path) return HttpResponse('success') else: return HttpResponseBadRequest('no data')
def json_operator_logs(request): 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_LOG_VIEW in auth_permissions.values(): return HttpResponse(serializers.serialize( "json", Operator_Logs.objects.all()), content_type="application/json") else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def index(request): template_url = 'settings/index.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) return render( request, template_url, { 'section': settings.BACKEND_SECTION_SETTINGS, 'title': 'Settings', 'name': 'settings', 'operator': operator, 'auth_permissions': auth_permissions, })
def view_product_request_items(request, pk): template_url = 'product-request-items/index.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_VIEW in auth_permissions.values(): try: model = Product_Requests.objects.get(product_request_id=pk) search_form = ProductRequestItemSearchIndexForm(request.POST or None) objects = Product_Request_Items.objects.filter( product_requests_product_request_id=model.product_request_id) if request.method == 'POST' and search_form.is_valid(): display_search = True table = ProductRequestItemsTable(objects) else: display_search = False table = ProductRequestItemsTable(objects) table.set_auth_permissions(auth_permissions) return render( request, template_url, { 'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS, 'title': Product_Requests.TITLE, 'name': Product_Requests.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'table': table, 'search_form': search_form, 'display_search': display_search, 'index_url': reverse("product_request_items_index", kwargs={'pk': pk}), 'select_multiple_url': reverse("product_request_items_select_multiple"), 'model': model, 'item_index_url': reverse("product_requests_view", kwargs={'pk': pk}), } ) except(TypeError, ValueError, OverflowError, Product_Requests.DoesNotExist): return HttpResponseNotFound('Not Found', content_type='text/plain') else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def index_assets(request): template_url = 'products/index-assets.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_PRODUCT_VIEW in auth_permissions.values( ): search_form = ProductSearchIndexForm(request.POST or None) if request.method == 'POST' and search_form.is_valid(): display_search = True objects = Products.objects.filter( product_type=Products.TYPE_ASSET).order_by( 'product_tag', 'product_title') table = ProductAssetsTable(objects) else: display_search = False objects = Products.objects.filter( product_type=Products.TYPE_ASSET).order_by( 'product_tag', 'product_title') table = ProductAssetsTable(objects) table.set_auth_permissions(auth_permissions) return render( request, template_url, { 'section': settings.BACKEND_SECTION_STOCK_ALL_ASSETS, 'title': Products.TITLE, 'name': Products.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'table': table, 'search_form': search_form, 'display_search': display_search, 'index_url': reverse("products_index_assets"), 'select_multiple_url': '#', }) else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def view(request, pk): template_url = 'operator_logs/view.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_LOG_VIEW in auth_permissions.values(): try: model = Operator_Logs.objects.get(operator_log_id=pk) model.operator_log_updated_at = Utils.get_convert_datetime( model.operator_log_updated_at, settings.TIME_ZONE, settings.APP_CONSTANT_DISPLAY_TIME_ZONE ) + ' ' + settings.APP_CONSTANT_DISPLAY_TIME_ZONE_INFO return render( request, template_url, { 'section': settings.BACKEND_SECTION_OPERATOR_LOGS, 'title': Operator_Logs.TITLE, 'name': Operator_Logs.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'model': model, 'index_url': reverse("operator_logs_index"), 'select_single_url': reverse("operator_logs_select_single"), }) except (TypeError, ValueError, OverflowError, Operator_Logs.DoesNotExist): return HttpResponseNotFound('Not Found', content_type='text/plain') else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def index(request): template_url = 'notifications/index.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) search_form = NotificationSearchIndexForm(request.POST or None) if request.method == 'POST' and search_form.is_valid(): display_search = True objects = Notifications.objects.filter(notification_to_id=operator.operator_id).order_by( '-notification_created_at') objects = Operators.objects.order_by('operator_name').all() table = NotificationsTable(objects) else: display_search = False objects = Notifications.objects.filter(notification_to_id=operator.operator_id).order_by( '-notification_created_at') table = NotificationsTable(objects) table.set_auth_permissions(auth_permissions) return render( request, template_url, { 'section': settings.BACKEND_SECTION_NOTIFICATIONS, 'title': Notifications.TITLE, 'name': Notifications.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'table': table, 'search_form': search_form, 'display_search': display_search, 'index_url': reverse("notifications_index"), } )
def index(request): template_url = 'operator_logs/index.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_LOG_VIEW in auth_permissions.values(): table = OperatorLogsTable( Operator_Logs.objects.all().order_by('-operator_log_id')[:100], Operators.get_auth_permissions(operator)) # [:1000] table.set_auth_permissions(auth_permissions) return render( request, template_url, { 'section': settings.BACKEND_SECTION_OPERATOR_LOGS, 'title': Operator_Logs.TITLE, 'name': Operator_Logs.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'table': table, 'index_url': reverse("operator_logs_index"), 'select_multiple_url': reverse("operator_logs_select_multiple"), }) else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def create(request): template_url = 'product-requests/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_CREATE in auth_permissions.values(): if request.method == 'POST': form = ProductRequestCreateForm(request.POST) # noinspection PyArgumentList if form.is_valid(): model = Product_Requests() model.product_request_code = Product_Requests.generate_random_number('product_request_code', 8) model.product_request_project = form.cleaned_data['product_request_project'] model.product_request_details = form.cleaned_data['product_request_details'] model.product_request_no_of_items = 0 model.product_request_created_at = Utils.get_current_datetime_utc() model.product_request_created_id = operator.operator_id model.product_request_created_by = operator.operator_name model.product_request_created_department = operator.operator_department model.product_request_created_role = operator.operator_role model.product_request_updated_at = Utils.get_current_datetime_utc() model.product_request_updated_id = operator.operator_id model.product_request_updated_by = operator.operator_name model.product_request_updated_department = operator.operator_department model.product_request_updated_role = operator.operator_role model.product_request_requested_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE model.product_request_requested_id = '' model.product_request_requested_by = '' model.product_request_requested_department = '' model.product_request_requested_role = '' model.product_request_reviewed_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE model.product_request_reviewed_id = '' model.product_request_reviewed_by = '' model.product_request_reviewed_department = '' model.product_request_reviewed_role = '' model.product_request_approved_updated_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE model.product_request_approved_updated_id = '' model.product_request_approved_updated_by = '' model.product_request_approved_updated_department = '' model.product_request_approved_updated_role = '' model.product_request_closed_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE model.product_request_closed_id = '' model.product_request_closed_by = '' model.product_request_closed_department = '' model.product_request_closed_role = '' model.product_request_cancelled_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE model.product_request_cancelled_id = '' model.product_request_cancelled_by = '' model.product_request_cancelled_department = '' model.product_request_cancelled_role = '' model.product_request_status = Product_Requests.STATUS_PENDING # noinspection PyCallByClass,PyTypeChecker model.save('Created') messages.info(request, 'Your stock request has been created successfully.') return redirect(reverse("product_requests_view", args=[model.product_request_id])) else: return render( request, template_url, { 'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS, 'title': Product_Requests.TITLE, 'name': Product_Requests.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, 'index_url': reverse("product_requests_index"), } ) else: form = ProductRequestCreateForm() return render( request, template_url, { 'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS, 'title': Product_Requests.TITLE, 'name': Product_Requests.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, 'index_url': reverse("product_requests_index"), } ) else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def create(request, id): template_url = 'product-request-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_CREATE in auth_permissions.values( ): try: product_request = Product_Requests.objects.get( product_request_id=id) if request.method == 'POST': form = ProductRequestItemCreateForm(request.POST) # noinspection PyArgumentList if form.is_valid(): model = Product_Request_Items() model.product_requests_product_request_id = product_request.product_request_id model.products_product_id = form.cleaned_data[ 'products_product_id'] product = Products.objects.get( product_id=model.products_product_id) model.product_request_item_product_type = product.product_type model.product_request_item_product_code = product.product_code model.product_request_item_product_tag = product.product_tag model.product_request_item_product_category = product.product_category model.product_request_item_product_title = product.product_title model.product_request_item_product_sub_title = product.product_sub_title model.product_request_item_product_quantity_initial = 0 model.product_request_item_product_quantity_ordered = form.cleaned_data[ 'product_request_item_product_quantity_ordered'] model.product_request_item_product_quantity_balance = 0 model.product_request_item_product_quantity_unit = product.product_quantity_unit model.product_request_item_created_at = Utils.get_current_datetime_utc( ) model.product_request_item_created_id = operator.operator_id model.product_request_item_created_by = operator.operator_name model.product_request_item_created_department = operator.operator_department model.product_request_item_created_role = operator.operator_role model.product_request_item_updated_at = Utils.get_current_datetime_utc( ) model.product_request_item_updated_id = operator.operator_id model.product_request_item_updated_by = operator.operator_name model.product_request_item_updated_department = operator.operator_department model.product_request_item_updated_role = operator.operator_role model.product_request_item_received_at = settings.APP_CONSTANT_DEFAULT_DATETIME_VALUE model.product_request_item_received_id = '' model.product_request_item_received_by = '' model.product_request_item_received_department = '' model.product_request_item_received_role = '' model.product_request_item_status = Product_Requests.STATUS_PENDING # noinspection PyCallByClass,PyTypeChecker model.save('Created') Product_Requests.update_grand_total( request, product_request, operator) messages.success(request, 'Item added successfully.') return redirect( reverse("product_requests_view", args=[product_request.product_request_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("product_requests_view", args=[product_request.product_request_id])) else: form = ProductRequestItemCreateForm( initial={ 'product_request_id': product_request.product_request_code, 'products_product_id': '', 'product_request_item_product_quantity_ordered': 0, }) return render( request, template_url, { 'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS, 'title': Product_Request_Items.TITLE, 'name': Product_Request_Items.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, }) except (TypeError, ValueError, OverflowError, Product_Requests.DoesNotExist, Product_Request_Items.DoesNotExist): return HttpResponseNotFound('Not Found', content_type='text/plain') else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def backup_restore(request): template_url = 'settings/backup-restore.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_SETTINGS_VIEW in auth_permissions.values( ): objects = [] files = [] for filename in os.listdir('backups'): filepath = os.path.join(settings.BASE_DIR, 'backups/') + filename f = open(filepath, 'r') file = File(f) (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(filepath) filename, file_extension = os.path.splitext(filepath) files.append(file) print(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) print("last modified: %s" % time.ctime(mtime)) print("size: %s" % os.path.getsize(filepath)) f.close() if file_extension == '.bz2': objects.append( Backups( backup_file_name=os.path.basename(filepath), backup_file_size=Utils.bytes_2_human_readable( os.path.getsize(filepath)), backup_file_created_at=mtime, backup_file_updated_at=mtime, )) table = BackupsTable(objects) table.set_auth_permissions(auth_permissions) return render( request, template_url, { 'section': settings.BACKEND_SECTION_SETTINGS, 'title': Backups.TITLE, 'name': Backups.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'table': table, 'index_url': reverse("backup_restore"), 'select_single_url': reverse("backup_restore_select_single"), 'select_multiple_url': reverse("backup_restore_select_multiple"), }) else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def import_excel(request): template_url = 'products/import-excel.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_OPERATOR_UPDATE in auth_permissions.values( ): if operator.operator_type != Operators.TYPE_SUPER_ADMIN: return HttpResponseForbidden('Forbidden', content_type='text/plain') else: if request.method == 'POST': form = ProductExcelImportForm(request.POST, request.FILES) if form.is_valid(): if 'excel_file' in request.FILES and \ request.FILES['excel_file']: excel_file = form.cleaned_data['excel_file'] import pandas as pd df = pd.read_excel(excel_file) matrix = df.values df = pd.DataFrame(df) error = '' success = 0 failed = 0 for index, row in df.iterrows(): print(index, row) try: type = row['type'] tag = row['tag'] title = row['title'] category = row['category'] fail = False try: product = Products.objects.get( product_tag=tag) except Products.DoesNotExist: product = None if product is None: product = Products() product.product_code = Products.generate_random_number( 'product_code', 8) product.product_sub_title = '' product.product_quantity_available = 0 product.product_quantity_unit = '' product.product_type = type product.product_tag = tag product.product_category = category product.product_title = title 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() success = success + 1 except Exception as e: failed = failed + 1 error = error + " <br> " + 'Error - [Row: ' + str( index) + '] ' + str(e) message = 'Success: ' + str( success) + ', Failed: ' + str(failed) message = message + error messages.warning(request, message) form = ProductExcelImportForm() return render( request, template_url, { 'section': settings.BACKEND_SECTION_SETTINGS, 'title': Products.TITLE, 'name': Products.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, }) else: messages.error( request, 'Error: Select excel file to import.') return render( request, template_url, { 'section': settings.BACKEND_SECTION_SETTINGS, 'title': Products.TITLE, 'name': Products.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, }) else: messages.error(request, 'Error: invalid form inputs.') return render( request, template_url, { 'section': settings.BACKEND_SECTION_SETTINGS, 'title': Products.TITLE, 'name': Products.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, }) else: form = ProductExcelImportForm() return render( request, template_url, { 'section': settings.BACKEND_SECTION_SETTINGS, 'title': Products.TITLE, 'name': Products.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, }) else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def backup_restore_select_single(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'] id = request.POST['id'] if action != '' and id is not None: if action == 'backup': if settings.ACCESS_PERMISSION_SETTINGS_VIEW in auth_permissions.values( ): try: call_command('archive') messages.success(request, 'Backup taken successfully.') except (TypeError, ValueError, OverflowError): return HttpResponseBadRequest( 'Bad Request', content_type='text/plain') else: return HttpResponseForbidden('Forbidden', content_type='text/plain') if action == 'delete': if settings.ACCESS_PERMISSION_SETTINGS_VIEW in auth_permissions.values( ): print(action + '-' + id) filepath = os.path.join(settings.BASE_DIR, 'backups/') + id print(filepath) if os.path.isfile(filepath): os.remove(filepath) messages.success(request, 'Backup file deleted 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: 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) action = request.POST['action'] id = request.POST['id'] if action != '' and id is not None: if action == 'download': if settings.ACCESS_PERMISSION_SETTINGS_VIEW in auth_permissions.values( ): print(action + '-' + id) filepath = os.path.join(settings.BASE_DIR, 'backups/') + id print(filepath) filename, file_extension = os.path.splitext(filepath) if file_extension == '.bz2' and os.path.exists( filepath): with open(filepath, 'rb') as fh: response = HttpResponse( fh.read(), content_type="application/x-gzip") response[ 'Content-Disposition'] = 'inline; filename=' + os.path.basename( filepath) return response else: return HttpResponseForbidden('Forbidden', content_type='text/plain') return HttpResponse('success', content_type='text/plain') else: return HttpResponseBadRequest('Bad Request', content_type='text/plain')
def index_inventory_assets(request): template_url = 'products/index-inventory-assets.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_INVENTORY_VIEW in auth_permissions.values( ): search_form = ProductInventorySearchIndexForm(request.POST or None) if request.method == 'POST' and search_form.is_valid(): display_search = True objects = Products.objects.all() objects = objects.filter(product_type=Products.TYPE_ASSET) objects = objects.order_by('product_tag', 'product_title') results = [] for item in objects: item.product_quantity_initial = 0 item.product_quantity_in = 0 inventory_items = Inventory_Items.objects.filter( products_product_id=item.product_id) for inventory_item in inventory_items: item.product_quantity_in = item.product_quantity_in + inventory_item.inventory_item_product_quantity_ordered item.product_quantity_out = 0 product_request_items = Product_Request_Items.objects.all() product_request_items = product_request_items.filter( products_product_id=item.product_id, product_request_item_status=Product_Request_Items. STATUS_RECEIVED) for product_request_item in product_request_items: item.product_quantity_out = item.product_quantity_out + product_request_item.product_request_item_product_quantity_ordered item.product_quantity_final = item.product_quantity_available results.append(item) table = ProductAssetsInventoryTable(objects) else: display_search = False objects = Products.objects.all() objects = objects.filter(product_type=Products.TYPE_ASSET) objects = objects.order_by('product_tag', 'product_title') results = [] for item in objects: item.product_quantity_initial = 0 item.product_quantity_in = 0 inventory_items = Inventory_Items.objects.filter( products_product_id=item.product_id) for inventory_item in inventory_items: item.product_quantity_in = item.product_quantity_in + inventory_item.inventory_item_product_quantity_ordered item.product_quantity_out = 0 product_request_items = Product_Request_Items.objects.all() product_request_items = product_request_items.filter( products_product_id=item.product_id, product_request_item_status=Product_Request_Items. STATUS_RECEIVED) for product_request_item in product_request_items: item.product_quantity_out = item.product_quantity_out + product_request_item.product_request_item_product_quantity_ordered item.product_quantity_final = item.product_quantity_available results.append(item) table = ProductAssetsInventoryTable(results) table.set_auth_permissions(auth_permissions) return render( request, template_url, { 'section': settings.BACKEND_SECTION_INVENTORY_ASSETS, 'title': Products.TITLE, 'name': Products.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'table': table, 'search_form': search_form, 'display_search': display_search, 'index_url': reverse("products_index_inventory_assets"), 'select_multiple_url': '#', }) else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def view(request, pk): template_url = 'product-requests/view.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_VIEW in auth_permissions.values(): try: model = Product_Requests.objects.get(product_request_id=pk) product_request_items = Product_Request_Items.objects.filter( product_requests_product_request_id=pk).all() if model.product_request_created_id == str( operator.operator_id) and model.product_request_status == Product_Requests.STATUS_PENDING: template_url = 'product-requests/view-edit.html' display_level_approval = False timeline_notifications = [] counter = -1 if model.product_request_requested_id != '': notification_timeline = NotificationsTimeline() notification_timeline.message = 'Requested <small>by ' + model.product_request_requested_role + '</small>' notification_timeline.datetime = Utils.get_convert_datetime(model.product_request_requested_at, settings.TIME_ZONE, settings.APP_CONSTANT_DISPLAY_TIME_ZONE) + ' ' + settings.APP_CONSTANT_DISPLAY_TIME_ZONE_INFO timeline_notifications.append(notification_timeline) if model.product_request_reviewed_id != '': notification_timeline = NotificationsTimeline() notification_timeline.message = 'Reviewed <small>by ' + model.product_request_reviewed_role + '</small>' notification_timeline.datetime = Utils.get_convert_datetime(model.product_request_reviewed_at, settings.TIME_ZONE, settings.APP_CONSTANT_DISPLAY_TIME_ZONE) + ' ' + settings.APP_CONSTANT_DISPLAY_TIME_ZONE_INFO timeline_notifications.append(notification_timeline) if model.product_request_approved_updated_id != '': notification_timeline = NotificationsTimeline() notification_timeline.message = 'Approved <small>by ' + model.product_request_approved_updated_role + '</small>' if model.product_request_status == Product_Requests.STATUS_REJECTED: notification_timeline.message = 'Rejected <small>by ' + model.product_request_approved_updated_role + '</small>' notification_timeline.datetime = Utils.get_convert_datetime( model.product_request_approved_updated_at, settings.TIME_ZONE, settings.APP_CONSTANT_DISPLAY_TIME_ZONE) + ' ' + settings.APP_CONSTANT_DISPLAY_TIME_ZONE_INFO timeline_notifications.append(notification_timeline) if model.product_request_status == Product_Requests.STATUS_REQUESTED: notification_timeline = NotificationsTimeline() model.product_request_readable_status = notification_timeline.message = "<b class='text-red'>Review pending from Stock Admin</b>" notification_timeline.datetime = '' timeline_notifications.append(notification_timeline) if model.product_request_status == Product_Requests.STATUS_REVIEWED: notification_timeline = NotificationsTimeline() model.product_request_readable_status = notification_timeline.message = "<b class='text-red'>Approval pending from Stock Admin</b>" notification_timeline.datetime = '' timeline_notifications.append(notification_timeline) if model.product_request_status == Product_Requests.STATUS_APPROVED: notification_timeline = NotificationsTimeline() model.product_request_readable_status = notification_timeline.message = "<b class='text-red'>Approved</b>" notification_timeline.datetime = '' timeline_notifications.append(notification_timeline) if model.product_request_status == Product_Requests.STATUS_REJECTED: notification_timeline = NotificationsTimeline() model.product_request_readable_status = notification_timeline.message = "<b class='text-red'>Rejected</b>" notification_timeline.datetime = '' timeline_notifications.append(notification_timeline) return render( request, template_url, { 'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS, 'title': Product_Requests.TITLE, 'name': Product_Requests.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'model': model, 'index_url': reverse("product_requests_index"), 'select_single_url': reverse("product_requests_select_single"), 'product_request_items': product_request_items, 'product_request_items_size': product_request_items, 'item_index_url': reverse("product_requests_view", kwargs={'pk': pk}), 'item_select_single_url': reverse("product_request_items_select_single"), 'status_html_tag': Product_Requests.get_status_html_tag(model), 'display_level_approval': display_level_approval, 'timeline_notifications': timeline_notifications, } ) except(TypeError, ValueError, OverflowError, Product_Requests.DoesNotExist): return HttpResponseNotFound('Not Found', content_type='text/plain') else: return HttpResponseForbidden('Forbidden', content_type='text/plain')
def create(request, order_id): template_url = 'order-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_CREATE in auth_permissions.values( ): # try: order = Orders.objects.get(order_id=order_id) if request.method == 'POST': form = OrderItemCreateForm(request.POST) # noinspection PyArgumentList if form.is_valid(): model = Order_Items() model.orders_order_id = order_id 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_usaid_approval = 0 model.order_item_created_at = Utils.get_current_datetime_utc( ) model.order_item_created_id = operator.operator_id model.order_item_created_by = operator.operator_name model.order_item_created_department = operator.operator_department model.order_item_created_role = operator.operator_role 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.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 = Orders.STATUS_PENDING # noinspection PyCallByClass,PyTypeChecker model.save('Created') Orders.update_grand_total(request, order, operator) messages.success(request, 'Item added successfully.') return redirect(reverse("orders_view", args=[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: form = OrderItemCreateForm( initial={ 'order_id': order.order_code, 'title': '', 'duration': 0, 'unit_price': 0, 'currency': Order_Items.CURRENCY_RWF, 'quantity_ordered': 0, '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, }) # 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 update(request, pk): template_url = 'product-requests/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 = Product_Requests.objects.get(product_request_id=pk) if request.method == 'POST': form = ProductRequestUpdateForm(request.POST) # noinspection PyArgumentList if form.is_valid(): model.product_request_project = form.cleaned_data['product_request_project'] model.product_request_details = form.cleaned_data['product_request_details'] model.product_request_updated_at = Utils.get_current_datetime_utc() model.product_request_updated_id = operator.operator_id model.product_request_updated_by = operator.operator_name model.product_request_updated_department = operator.operator_department model.product_request_updated_role = operator.operator_role model.save() messages.success(request, 'Updated successfully.') return redirect(reverse("product_requests_view", args=[model.product_request_id])) else: return render( request, template_url, { 'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS, 'title': Product_Requests.TITLE, 'name': Product_Requests.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, 'model': model, 'index_url': reverse("product_requests_index"), } ) else: form = ProductRequestUpdateForm( initial={ 'product_request_project': model.product_request_project, 'product_request_details': model.product_request_details, } ) return render( request, template_url, { 'section': settings.BACKEND_SECTION_STOCK_ALL_REQUESTS, 'title': Product_Requests.TITLE, 'name': Product_Requests.NAME, 'operator': operator, 'auth_permissions': auth_permissions, 'form': form, 'model': model, 'index_url': reverse("product_requests_index"), } ) except(TypeError, ValueError, OverflowError, Product_Requests.DoesNotExist): return HttpResponseNotFound('Not Found', 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')