You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
The provided Razor view is designed to create a new order in an MVC structure using ASP.NET Core. Let's break it down:
1. Directives and Model Declaration:
The view starts by importing necessary namespaces with the @using directive.
The @model directive is used to specify the expected data type, which is OrderCreateEditDto.
2. ViewData and Layout:
ViewData is used to set metadata for the page, including the title and breadcrumb navigation.
3. Styles Section:
There's a section titled Styles that imports a specific CSS stylesheet for styling the page.
4. Content Display:
If an error exists (as determined by ViewData["Error"]), an error message is shown.
The main content starts with a form that collects information about the new order.
Inside the form:
Tabs: The form contains a tabbed navigation. However, there's only one tab titled "Details" in this view.
Order Details: The order details section captures basic order information such as order number, project name, city, customer name, and car space quantity.
Prepared By & Release Date: This section captures the user preparing the order (automatically fetched from the user's claims) and the current date and time.
Select Order Criteria: This is where the user can select products and their specifications. Dropdowns are provided for selecting a product, sub-product, width, length, level, and grid. There's also a field for specifying the quantity and a button to add the selected product configuration to the order.
List of Selected Products: Displays a table of all selected products and their specifications. There's also an option to delete a product from the list.
Submission: A button is provided to submit the form and create the order. If there was an error during creation (as determined by ViewData["CreateError"]), an error message is displayed.
5. Scripts Section:
This section initializes a JavaScript variable with the list of sub-products from the ViewData, making it accessible to client-side scripts.
It also imports a specific JavaScript file (order.create.js) presumably containing logic related to creating orders.
In-depth Analysis:
Tabbed Interface: Even though there's just one tab in this view, the design suggests that the application might have been designed to accommodate more tabs in the future.
Dynamic Dropdown Population: The design suggests that the dropdowns for sub-product, width, length, level, and grid might be populated dynamically based on the selected product. The view contains placeholder comments suggesting where the values might be fetched from.
User Information Auto-population: The "Prepared By" field is auto-populated using the logged-in user's information, making the process seamless for the user.
Dynamic Table: The table for selected products is dynamic, allowing users to add multiple products to the order before submission.
Client-Side Data Initialization: The view serializes some of its data into JavaScript variables. This is a common pattern to pass data from the server side to client-side scripts, ensuring that client-side scripts have the necessary data to function.
In summary, this view provides a user-friendly interface for creating new orders. It's designed with usability in mind, allowing users to select multiple products and their specifications before submitting the order. The use of dynamic dropdowns and tables makes the process seamless and efficient. Integrated error handling ensures that users are notified of any issues during the creation process.
This provided Razor view is for editing an order in the MVC structure of ASP.NET Core. It utilizes the OrderCreateEditDto model which seems to contain details of an order that can be created or edited. Here's a breakdown:
1. Directives and Model Declaration:
The view imports the necessary namespaces using the @using directive.
The @model directive is used to specify the expected data type for this view.
2. ViewData and Layout:
ViewData["Title"] and ViewData["Breadcrumb"] are used to set meta-data for the page. The breadcrumb data gives a hint about the page hierarchy, allowing users to navigate back to previous pages easily.
3. Styles Section:
The section titled Styles imports several CSS stylesheets, some of which are specific to the DataTables jQuery plugin, and some others are specific to different sections or features of the order editing process.
4. Content Display:
If there's an error (as determined by ViewData["Error"]), it displays the error message in a styled div.
If no error is present, the main content of the view is displayed. The main content features:
A navigation bar (tabbed interface) to toggle between "Order Header" and "BOM" (Bill of Materials).
Within these tabs, partial views are rendered using the Html.PartialAsync method. This method renders other Razor views (here named OrderHeader.Edit.cshtml and OrderBom.Edit.cshtml respectively) inside the current view.
A loading spinner is displayed inside the "BOM" tab, suggesting that some asynchronous operations may be taking place when this tab is accessed.
5. Scripts Section:
This section loads various JavaScript libraries and scripts.
A toast notification is shown if there was a successful update, based on the presence of TempData["UpdateSuccess"].
The script section also serializes some model data and ViewData into JavaScript variables, making them available for client-side scripts. This is a common pattern to pass data from server-side code to client-side JavaScript.
Several DataTables-related scripts are loaded, suggesting that the view might be using the DataTables jQuery plugin for displaying and managing tables.
Specific scripts related to different aspects of the order editing process (order.edit.js, order.edit.header.js, and order.edit.bom.js) are also loaded.
In-depth Analysis:
Tabbed Interface: The view employs a tabbed interface, which allows users to easily navigate between different sections of the order editing process without having to load a new page.
Partial Views: The use of partial views suggests a modular design. This is a good practice as it allows for reusability of views and separation of concerns. The main view acts as a container, while specific functionalities are encapsulated in separate partial views.
Dynamic Content Loading: The presence of the loading spinner inside the "BOM" tab hints that some data might be loaded asynchronously when this tab is accessed. This could mean a more responsive UI as not all data needs to be loaded upfront.
Error Handling: The view has built-in error handling, displaying a user-friendly error message when something goes wrong.
DataTables Integration: The inclusion of several DataTables-related styles and scripts suggests that this view uses the DataTables jQuery plugin. DataTables provides functionalities like searching, paging, and sorting to tables.
Client-Side Data Initialization: The view serializes some of its data into JavaScript variables. This is a common pattern to pass data from the server side to client-side scripts, ensuring that client-side scripts have the necessary data to function.
In summary, this view provides a user-friendly interface for editing orders, with a tabbed layout to separate different sections of the editing process. It employs a modular design using partial views and offers dynamic content loading for better responsiveness. Integrated error handling, toast notifications, and the DataTables plugin further enhance the user experience.
The code is a Razor View for the MVC structure in ASP.NET Core. The view is designed to display a list of orders. Let's break down the main components:
1. Directives & Model Declaration:
@using System.Data and @using KlausBOM.Models are directives that import necessary namespaces to be used in the Razor view.
@model DataTable sets the type of the model that the view expects to receive from the controller, which is a DataTable in this case.
2. ViewData and Layout:
ViewData["Title"] and ViewData["Breadcrumb"] are used to set page-specific data that might be used by the layout or other parts of the rendered view.
Layout = "~/Views/Shared/_Layout.cshtml"; sets the layout page to be used with this view.
3. Styles Section:
There's a section dedicated to styles, which includes a specific stylesheet for this view.
4. Content Display:
If there's an error (as determined by ViewData["Error"]), it displays an error message in a styled div.
If there's no error, it displays a table of orders.
The headers of the table are dynamically generated based on the columns in the DataTable.
The rows are also dynamically generated from the DataTable. If a column is named "Status", it adds a colored badge based on the status value, otherwise, it directly displays the value.
5. Scripts Section:
If the TempData["CreateSuccess"] is not null, it will display a toast notification with a success message.
Various scripts are added to the view, especially related to DataTables and the specific functionalities of the page.
In-depth Analysis:
DataTable Rendering: The view is designed to display a dynamic table based on a DataTable. This is evident from the foreach loops iterating over the columns and rows of the DataTable. This offers flexibility in terms of what columns and data to display, as it can adapt to different DataTable structures.
Dynamic Status Rendering: There's a specific check for a column named "Status". For this column, instead of just displaying the text, the view adds a badge with a color that depends on the status value (e.g., "ON_HOLD" gets a warning badge).
Error Handling: Before displaying the main content, the view checks if there's an error message in ViewData["Error"]. If so, it displays that error prominently, providing feedback to the user.
Toast Notifications: A toast notification is a non-intrusive, small popup that provides feedback to the user. In this view, a toast is shown if an order has been successfully created.
Script Inclusions: The view includes various JavaScript files, especially those related to DataTables and order-specific functionalities. This suggests that there's dynamic behavior on the client side, like sorting or filtering the displayed orders.
Styling: The view has a dedicated stylesheet, ensuring the orders are displayed in a styled and user-friendly manner.
In summary, this view is designed to display a list of orders in a table format, with dynamic rendering based on the data it receives. It provides feedback to the user through toast notifications and error messages and includes scripts to enhance its functionality on the client side.
This is a Razor view named OrderBom.Edit.cshtml designed for editing or managing the Bill of Materials (BOM) for a specific order in an ASP.NET Core MVC application. The BOM typically lists the parts and quantities required to manufacture a product. Let's break down the key components:
1. Directives and Model Declaration:
Relevant namespaces are imported using the @using directive.
The expected model type for this view is declared as OrderCreateEditDto using the @model directive.
2. Order BOM Table:
A table is defined with the ID order-bom-list to list out the BOM details.
The table includes columns for various attributes related to the BOM, such as level, part group name, part number, BOM line, item description, specification, and many others.
3. Modal for Adding BOM Child Part:
A modal (a dialog box/pop-up window) is defined with the ID add-order-bom-child-modal which appears when the user wants to add a new part to the BOM.
Inside this modal:
A checkbox lets users decide if they want to add an entire assembly.
A dropdown lets users select a BOM part.
There's an input field for the part description, which is read-only.
If the user is adding an entire assembly, additional input fields for part position, BOM line, quantity, and total quantity are displayed.
There's another checkbox to decide if a child level is required for the part.
An error message can be displayed if there's an issue while adding the part.
There are buttons to either cancel the addition or save the new part.
4. JavaScript Section:
A Scripts section is defined at the end, which can be populated with JavaScript functions or scripts specific to this view. For instance, the onAddNewBomChild() function is invoked when the "Add" button in the modal is clicked. However, the implementation of this function isn't provided in the given view. It's likely defined in an external JavaScript file or provided elsewhere in the application.
Summary:
This view provides an interface for managing the Bill of Materials for an order. Users can view the current BOM details in a table and have the option to add new parts to the BOM using a modal. The design ensures that users have a clear and structured way to manage the BOM, with specific fields to capture all relevant information. The dynamic nature of the modal, which adjusts its fields based on user choices (like adding an entire assembly), ensures flexibility while maintaining a clean user interface.
The provided Razor view is designed to create a new order in an MVC structure using ASP.NET Core. Let's break it down:
1. Directives and Model Declaration:
The view starts by importing necessary namespaces with the @using directive.
The @model directive is used to specify the expected data type, which is OrderCreateEditDto.
2. ViewData and Layout:
ViewData is used to set metadata for the page, including the title and breadcrumb navigation.
3. Styles Section:
There's a section titled Styles that imports a specific CSS stylesheet for styling the page.
4. Content Display:
If an error exists (as determined by ViewData["Error"]), an error message is shown.
The main content starts with a form that collects information about the new order.
Inside the form:
Tabs: The form contains a tabbed navigation. However, there's only one tab titled "Details" in this view.
Order Details: The order details section captures basic order information such as order number, project name, city, customer name, and car space quantity.
Prepared By & Release Date: This section captures the user preparing the order (automatically fetched from the user's claims) and the current date and time.
Select Order Criteria: This is where the user can select products and their specifications. Dropdowns are provided for selecting a product, sub-product, width, length, level, and grid. There's also a field for specifying the quantity and a button to add the selected product configuration to the order.
List of Selected Products: Displays a table of all selected products and their specifications. There's also an option to delete a product from the list.
Submission: A button is provided to submit the form and create the order. If there was an error during creation (as determined by ViewData["CreateError"]), an error message is displayed.
5. Scripts Section:
This section initializes a JavaScript variable with the list of sub-products from the ViewData, making it accessible to client-side scripts.
It also imports a specific JavaScript file (order.create.js) presumably containing logic related to creating orders.
In-depth Analysis:
Tabbed Interface: Even though there's just one tab in this view, the design suggests that the application might have been designed to accommodate more tabs in the future.
Dynamic Dropdown Population: The design suggests that the dropdowns for sub-product, width, length, level, and grid might be populated dynamically based on the selected product. The view contains placeholder comments suggesting where the values might be fetched from.
User Information Auto-population: The "Prepared By" field is auto-populated using the logged-in user's information, making the process seamless for the user.
Dynamic Table: The table for selected products is dynamic, allowing users to add multiple products to the order before submission.
Client-Side Data Initialization: The view serializes some of its data into JavaScript variables. This is a common pattern to pass data from the server side to client-side scripts, ensuring that client-side scripts have the necessary data to function.
In summary, this view provides a user-friendly interface for creating new orders. It's designed with usability in mind, allowing users to select multiple products and their specifications before submitting the order. The use of dynamic dropdowns and tables makes the process seamless and efficient. Integrated error handling ensures that users are notified of any issues during the creation process.
The order.create.js file contains JavaScript functionalities for the "Order Create" page. Here's a breakdown of its main components:
1. Document Ready Function:
When the page has finished loading:
Event listeners are attached to the Product and SubProduct dropdowns to update the related dropdowns when their values change.
DataTables library is initialized for a table with specific options.
Event listeners are attached to the "Add Product" and "Submit" buttons to handle their respective functionalities.
2. Order Creation Function (onCreateOrder):
Extracts values from various input fields.
Makes a POST request to the server to create an order with the given data.
Shows success or error messages based on the response from the server.
3. Show Error Function (showError):
Displays an error message using the toast notification.
4. Order Configuration Management:
Variables (orderListTable, orderConfigs, etc.) are declared to manage order configurations.
addToSelectedOrderConfig: Adds a selected product configuration to the DataTable and the orderConfigs array.
removeOrderConfig: Removes a product configuration from the DataTable and the orderConfigs array.
5. Dropdown Management Functions:
setSubGroupDropdown: Updates the SubProduct dropdown based on the selected product.
setParameterDropdown: Sets the values for the Width, Length, Grid, and Level dropdowns based on the selected product and subproduct.
setSingleParameterDropdown: A helper function to populate individual dropdowns (like Width, Length, etc.) based on provided data.
Summary:
This script enhances the user experience on the "Order Create" page. It dynamically updates dropdown values based on user selections, manages product configurations in a DataTable, and communicates with the server to create a new order. The script utilizes the DataTables library for table management and shows notifications using a toast system.
$(document).ready(function(){letisBomTabClicked=false;$("#order-nav-bom").on("click",()=>{if(!isBomTabClicked){loadBoms();isBomTabClicked=true;}});$("#add-order-bom-child-modal").on('shown.bs.modal',function(){$("#add-order-bom-child-modal #PartId").focus();setParentPartDescription();});$("#add-order-bom-child-modal #PartId").select2({dropdownParent: $("#add-order-bom-child-modal")});$("#add-order-bom-child-modal #PartId").change((e)=>{setParentPartDescription();});$("#add-order-bom-child-modal #isEntireAssembly").prop("checked",true);$("#add-order-bom-child-modal #isEntireAssembly").change((e)=>{constisChecked=$("#add-order-bom-child-modal #isEntireAssembly").prop("checked");if(isChecked){$("#add-order-bom-child-modal #assembly").removeClass("d-block");$("#add-order-bom-child-modal #assembly").addClass("d-none");$("#add-order-bom-child-modal #requireChildLevel").removeClass("d-none");$("#add-order-bom-child-modal #requireChildLevel").addClass("form-group");}else{$("#add-order-bom-child-modal #assembly").removeClass("d-none");$("#add-order-bom-child-modal #assembly").addClass("d-block");$("#add-order-bom-child-modal #requireChildLevel").removeClass("form-group");$("#add-order-bom-child-modal #requireChildLevel").addClass("d-none");}});$("#add-order-bom-child-modal #hasChild").prop("checked",true);});varobjecOrderConfig;functionloadAddBomChildModal(){isLoadingAdd();//$("#add-order-bom-child-modal #PartId").val(parentPartId);//$("#add-order-bom-child-modal #ParentPartNumber").val(parentPartNumber);//$("#add-order-bom-child-modal #ParentPartDescription").val(parentPartName);constorderId=$("#OrderId").val();// Get Child Partfetch("/api/OrderBoms/AvailableBomParts/"+orderId,{headers: {"Content-Type": "application/json"},credentials: "include",method: "GET",}).then(response=>{if(!response.ok){returnresponse.text().then(text=>{thrownewError(text)})}returnresponse.json();}).then(json=>{$("#add-order-bom-child-modal #PartId").find('option').remove();json.forEach((part)=>{$("#add-order-bom-child-modal #PartId").append(` <option value='${part.PartId}' data-part-description='${part.Name}' >${part.PartNumber}</option> `);});isLoadingRemove();$("#add-order-bom-child-modal #errorBomChild").text('');$("#add-order-bom-child-modal").modal('show');}).catch(response=>{isLoadingRemove();toast("Error",response.message,"error");});}functionloadOrderCriteria(){fetch("/api/Orders/OrderDetails/"+$("#OrderId").val(),{headers: {"Content-Type": "application/json"},credentials: "include"}).then(response=>{if(!response.ok){returnresponse.text().then(text=>{thrownewError(text)})}returnresponse.json();}).then(json=>{objecOrderConfig=json;});}functiononAddNewBomChild(){$("#add-order-bom-child-modal #errorBomChild").text('');constpartId=$("#add-order-bom-child-modal #PartId").val();consttotalWeight=$("#add-order-bom-child-modal #TotalWeight").val();constunitWeight=$("#add-order-bom-child-modal #UnitWeight").val();constpartRate=$("#add-order-bom-child-modal #PartRate").val();consttotalCost=$("#add-order-bom-child-modal #TotalCost").val();constpartPosition=$("#add-order-bom-child-modal #PartPosition").val();constpartQuantity=$("#add-order-bom-child-modal #PartQuantity").val();constbomLine=$("#add-order-bom-child-modal #BomLine").val();consttotalQuantity=$("#add-order-bom-child-modal #PartTotalQuantity").val();constisAssembly=$("#add-order-bom-child-modal #isEntireAssembly").prop("checked");consthasChild=$("#add-order-bom-child-modal #hasChild").prop("checked");if(!isAssembly){if(!partPosition||partPosition<=0){$("#add-order-bom-child-modal #errorBomChild").text('Part Position must be a positive integer!!');return;}if(!partQuantity||partQuantity<=0){$("#add-order-bom-child-modal #errorBomChild").text('Part Quantity must be a positive integer!!');return;}if(!bomLine||bomLine<=0){$("#add-order-bom-child-modal #errorBomChild").text('BOM Line must be a positive integer!!');return;}if(!totalQuantity||totalQuantity<=0){$("#add-order-bom-child-modal #errorBomChild").text('Total Quantity must be a positive integer!!');return;}}isLoadingAdd();constorderId=$("#OrderId").val();fetch("/api/OrderBoms/"+orderId,{headers: {"Content-Type": "application/json"},credentials: "include",method: "POST",body: JSON.stringify({OrderId: orderId,PartId: partId,PartPosition: partPosition,BomLine: bomLine,Quantity: partQuantity,TotalQuantity: totalQuantity,UnitWeight: unitWeight,TotalWeight: totalWeight,PartRate: partRate,TotalCost: totalCost,HasChild: hasChild})}).then(response=>{if(!response.ok){returnresponse.text().then(text=>{thrownewError(text)})}isLoadingRemove();toast("Add Part to Order BOM","Part has been added successfully!","success",()=>location.reload());}).catch(response=>{isLoadingRemove();toast("Error",response.message,"error");});}functionsetParentPartDescription(){letselectedOption=$("#add-order-bom-child-modal #PartId option:selected")[0];letpartName=$(selectedOption).attr("data-part-description");$("#add-order-bom-child-modal #PartDescription").val(partName);}varobjectOrderBoms;functionloadBoms(){isLoadingAdd();constorderId=$("#OrderId").val();fetch("/api/OrderBoms/"+orderId,{headers: {"Content-Type": "application/json"},credentials: "include"}).then(response=>{if(!response.ok){returnresponse.text().then(text=>{thrownewError(text)})}returnresponse.json();}).then(json=>{// TODO CodeobjectOrderBoms=json;setBomDataTable(json);isLoadingRemove();}).catch(error=>{console.log(error);isLoadingRemove();toast("Failed to fetch","Error: "+error.message,"error");});loadOrderCriteria();}varorderBomTable;functionsetBomDataTable(orderBoms){orderBoms.forEach((orderBom)=>{letappendRow=` <tr> <td> </td> <td>${orderBom.OrderBomId} </td> <td>${orderBom.PartGroupName} </td> <td>${orderBom.PartNumber} </td> <td>${orderBom.BomLine??""} </td> <td>${orderBom.PartDescription} </td> <td>${orderBom.Specification??""} </td> <td>${orderBom.PartPosition??""} </td> <td>${orderBom.DrawingNo??""} </td> <td>${orderBom.RefNo??""} </td> <td>${orderBom.InfoWorldNo??""} </td> <td>${orderBom.Uom} </td> <td>${orderBom.QuantityPerMachine??""} </td> <td>${orderBom.TotalQuantity??""} </td> <td>${orderBom.UnitWeight??""} </td> <td>${orderBom.TotalWeight??""} </td> <td>${orderBom.PartRate??""} </td> <td>${orderBom.TotalCost??""} </td> <td>${orderBom.PartType??""} </td> <td> <button type="button" class="btn btn-outline-danger" name="btnDeleteOrderBom" onclick="onConfirmDeleteBom('${orderBom.OrderBomId}')"> <i class="fas fa-trash-alt"></i> </button> </td> </tr> `;$("table#order-bom-list tbody").append(appendRow);});vargroupColumn=2;varorderBomDatatableOptions={dom: 'BfrPtip',stateSave: true,searchPanes: {layout: 'columns-4',initCollapsed: true},lengthMenu: [[10,25,50,-1],['10 rows','25 rows','50 rows','Show all']],order: [[groupColumn,'asc']],drawCallback: function(settings){varapi=this.api();varrows=api.rows({page: 'current'}).nodes();varlast=null;api.column(groupColumn,{page: 'current'}).data().each(function(group,i){if(last!==group){$(rows).eq(i).before('<tr class="bom-list-group-bg"><td colspan="18" class="bom-list-group-txt"><span>'+group+'</span></td></tr>');last=group;}});},buttons: ['colvis','pageLength',{extend: 'collection',className: 'btn btn-warning ml-2',text: 'Export Data',buttons: [{extend: 'excelHtml5',text: '<i class="fas fa-file-excel"></i> Dispatch BOM Excel',action: function(){ExportDispatchedToExcel(`Dispatch-BOM-${$("#OrderNumber").val()}`);}},{extend: 'excelHtml5',text: '<i class="fas fa-file-excel"></i> Detailed BOM Excel',action: function(){ExportDetailedToExcel(`Detailed-BOM-${$("#OrderNumber").val()}`);}},{extend: 'csvHtml5',text: '<i class="fas fa-file-csv"></i> CSV',title: `Dispatch BOM : ${$("#OrderNumber").val()}`,filename: `Dispatch-BOM-${$("#OrderNumber").val()}`,extension: '.csv',stateSave: true,exportOptions: {columns: ':not(:last-child):not(:first-child):visible',rows: function(idx,data,node){if($("table#order-bom-list tbody tr.selected").length==0){returntrue;}if($(node).hasClass("selected")){returntrue;}returnfalse;}}},]}],columnDefs: [{targets: 0,orderable: false,searchable: false,render: function(data,type,row,meta){return` <a href='#' class='datatable-row-action' name='expand-child'> <i class="fas fa-plus-circle" onclick="onExpandChildClick(this)"></i> </a> `;},},{targets: [1,groupColumn],visible: false,orderable: false,searchable: false},{targets: [4,5,6,7,8,9,10,11,12,14],orderable: false,searchable: false},],aaSorting: [],language: {paginate: {previous: '<i class="fas fa-long-arrow-alt-left"></i>',next: '<i class="fas fa-long-arrow-alt-right"></i>',}}}orderBomTable=$('#order-bom-list').DataTable(orderBomDatatableOptions);//console.log(orderBomTable.searchPanes);//orderBomTable.searchPanes.container().prependTo(orderBomTable.table().container());//orderBomTable.searchPanes.resizePanes();letbulkActions=` <div class="dropdown float-md-right text-center ml-md-3 mb-3 mb-md-0 datatables-actions" id="datatables-bulk-actions"> <button type="button" class="btn btn-info disabled dropdown-toggle dropleft" data-toggle="dropdown" aria-expanded="false" aria-haspopup="true" id="btn-dropdown-order-bom-bulk-actions"> <i class="fas fa-bars"></i> </button> <div class="dropdown-menu dropdown-menu-right">`;if(currentRoleId==1){bulkActions+=`<a href="#" class="dropdown-item text-danger" id="bulk-delete-order-boms"> <i class="fas fa-trash-alt"></i> Delete Order BOMs </a>`;}bulkActions+=` </div> </div> `;$("#order-bom-list_wrapper > div:first-child").before(bulkActions);$("#bulk-delete-order-boms").on("click",()=>{lettitle="";letselectedOrderBomIds=Array.from(orderBomTable.rows(".selected").data().map((rowData)=>rowData[1]));if(selectedOrderBomIds.length>1){title=`Delete ${selectedOrderBomIds.length} Order BOMs`;}else{title=`Delete Order BOM`;}confirmDelete({title: title,text: "Do you really want to delete these Order BOMs? This cannot be reverted!",deleteConfirmCallback: (isSoftDelete)=>{returnfetch(isSoftDelete ? "/api/OrderBoms/DeleteOrderBoms"
: "/api/OrderBoms/HardDeleteOrderBoms",{headers: {"Content-Type": "application/json"},credentials: "include",method: "POST",body: JSON.stringify(selectedOrderBomIds)}).then(response=>{if(!response.ok){returnresponse.text().then(text=>{thrownewError(text)})}returnresponse.json();}).catch(error=>{Swal.showValidationMessage(error.message);});}},{title: "Delete Order BOMs",details: "Order BOMs have been deleted successfully!",icon: 'success',confirmCallback: ()=>location.reload()});});letaddButtons=` <div class="additional-buttons float-md-left text-center ml-md-5 mb-3 mb-md-2"> <a class="btn btn-success mr-2 disabled" id="btnUpdatePart"> <i class="fas fa-edit mr-2"></i> Update Part </a> <a class="btn btn-success" id="btnAddPart" href="#"> <i class="fas fa-plus mr-2"></i> Add Part </a> </div> `;$("#order-bom-list_wrapper > div#order-bom-list_filter").after(addButtons);$("a#btnAddPart").on("click",(e)=>{loadAddBomChildModal();});$("a#btnUpdatePart").on("click",(e)=>{constselectedPart=orderBomTable.row(".selected").data();constorderBomId=selectedPart[1];window.location.href="/OrderBoms/Edit/"+orderBomId;});$("table#order-bom-list tbody").on("click","tr",function(){if($(this).find("table").length==0&&$(this).parents("table[name='order-child-list']").length==0){if($(this).hasClass("selected")){//$("#btnUpdatePart").addClass("disabled");$(this).removeClass("selected");}else{//orderBomTable.$("tr.selected").removeClass("selected");$(this).addClass("selected");//$("#btnUpdatePart").removeClass("disabled");}if(orderBomTable.$("tr.selected").length==1){$("#btnUpdatePart").removeClass("disabled");}else{$("#btnUpdatePart").addClass("disabled");}if(orderBomTable.$("tr.selected").length>0){$("#btn-dropdown-order-bom-bulk-actions").removeClass("disabled");}else{$("#btn-dropdown-order-bom-bulk-actions").addClass("disabled");}//console.log(orderBomTable.rows(".selected").data());}});}functiononConfirmDeleteBom(orderBomId){confirmDelete({title: "Delete Order BOM",text: "Do you really want to delete this Order BOM? The child parts of this Order BOM will be also deleted. This cannot be reverted!",deleteConfirmCallback: ()=>{returnfetch("/api/OrderBoms/Delete/"+orderBomId,{headers: {"Content-Type": "application/json"},credentials: "include",method: "POST",}).then(response=>{if(!response.ok){returnresponse.text().then(text=>{thrownewError(text)})}returnresponse.json();}).catch(error=>{Swal.showValidationMessage(error.message);});}},{title: "Delete Order BOM",details: "Order BOM has been deleted successfully!",icon: 'success',confirmCallback: ()=>location.reload()});}asyncfunctiononExpandChildClick(element){consttr=$(element).parents("tr");constrow=orderBomTable.row(tr);if(row.child.isShown()){$(element).removeClass("fa-minus-circle");$(element).addClass("fa-plus-circle");row.child.hide();tr.removeClass('shown');}else{// Open rowconstchildren=awaitgetOrderBomChildParts(row.data()[1]);$(element).removeClass("fa-plus-circle");$(element).addClass("fa-minus-circle");if(children.length==0){row.child("No Child Part!").show();}else{row.child(childFormat(children)).show();}tr.addClass("shown");}}ExportDispatchedToExcelasyncfunctionExportDispatchedToExcel(name){constorderId=$("#OrderId").val();isLoadingAdd();$.ajax({url: "/api/OrderBoms/ExportDispatchedToExcel/"+orderId,method: 'GET',xhrFields: {responseType: 'blob'},success: function(data,status,xhr){isLoadingRemove();varblob=newBlob([data],{type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'});varurl=URL.createObjectURL(blob);varlink=document.createElement('a');link.href=url;link.download=name+'.xlsx';link.click();URL.revokeObjectURL(url);},error: function(xhr,status,error){console.log(error)isLoadingRemove();}});}asyncfunctionExportDetailedToExcel(name){constorderId=$("#OrderId").val();isLoadingAdd();$.ajax({url: "/api/OrderBoms/ExportDetailedToExcel/"+orderId,method: 'GET',xhrFields: {responseType: 'blob'},success: function(data,status,xhr){isLoadingRemove();varblob=newBlob([data],{type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'});varurl=URL.createObjectURL(blob);varlink=document.createElement('a');link.href=url;link.download=name+'.xlsx';link.click();URL.revokeObjectURL(url);},error: function(xhr,status,error){console.log(error)isLoadingRemove();}});}//ExportDispatchedToExcelasyncfunctionExportDispatchedToExcel(name){constorderId=$("#OrderId").val();isLoadingAdd();$.ajax({url: "/api/OrderBoms/ExportDispatchedToExcel/"+orderId,method: 'GET',xhrFields: {responseType: 'blob'},success: function(data,status,xhr){isLoadingRemove();varblob=newBlob([data],{type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'});varurl=URL.createObjectURL(blob);varlink=document.createElement('a');link.href=url;link.download=name+'.xlsx';link.click();URL.revokeObjectURL(url);},error: function(xhr,status,error){console.log(error)isLoadingRemove();}});}asyncfunctionExportDetailedToExcel(name){constorderId=$("#OrderId").val();isLoadingAdd();$.ajax({url: "/api/OrderBoms/ExportDetailedToExcel/"+orderId,method: 'GET',xhrFields: {responseType: 'blob'},success: function(data,status,xhr){isLoadingRemove();varblob=newBlob([data],{type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'});varurl=URL.createObjectURL(blob);varlink=document.createElement('a');link.href=url;link.download=name+'.xlsx';link.click();URL.revokeObjectURL(url);},error: function(xhr,status,error){console.log(error)isLoadingRemove();}});}asyncfunctiongetOrderBomChildParts(orderBomId){isLoadingAdd();returnawaitfetch("/api/OrderBoms/Children/"+orderBomId,{headers: {"Content-Type": "application/json"},credentials: "include"}).then(response=>{if(!response.ok){returnresponse.text().then(text=>{thrownewError(text)})}returnresponse.json();}).then(json=>{// TODO Code//setBomDataTable(json);isLoadingRemove();returnjson;}).catch(error=>{console.log(error);isLoadingRemove();toast("Failed to fetch","Error: "+error.message,"error");});}functionchildFormat(children){lettable=` <table class="table table-responsive-lg table-hover datatable-show-all ms-5" name="order-child-list" id="order-child-list-${children[0].OrderBomId}" style="white-space: nowrap;width: fit-content"> `;table+=` <tbody>`;children.forEach((child)=>{table+=` <tr> <td></td> <td>${child.ParentPartNumber}</td> <td>${child.BomLine??""}</td> <td>${child.ParentPartName}</td> <td>${child.ParentPartSpecification}</td> <td>${child.ChildPartPosition??""}</td> <td>${child.ParentPartDrawingNumber}</td> <td>${child.ParentPartRefNumber}</td> <td>${child.ParentPartInfoWorldNumber}</td> <td>${child.ParentPartUom}</td> <td>${child.Quantity??""}</td> <td>${child.ParentPartType}</td>`;table+=` </tr> `;});table+=`</tbody> </table> `;returntable;}
The JavaScript file order.edit.bom.js is primarily meant to handle the Bill of Materials (BOM) tab functionality for an order. Here's a high-level overview:
Initialization:
When the document is ready, several event listeners are set up, including for the BOM tab click, modal show, and several form elements' value changes.
Some default values and properties are set for form elements.
Fetching and Displaying Data:
loadBoms(): Fetches and displays the list of BOMs for a particular order.
loadOrderCriteria(): Fetches order details.
loadAddBomChildModal(): Prepares and shows a modal to add a child part to the BOM.
setBomDataTable(orderBoms): Populates the BOM table using the DataTables library.
Event Handlers:
Handlers to focus on certain input fields when the modal is shown.
Handlers to update the form's layout based on checkbox changes.
Handlers to add or update BOM child parts.
Handlers to expand or collapse child parts for a BOM entry.
CRUD Operations:
onAddNewBomChild(): Adds a new child part to the BOM.
onConfirmDeleteBom(orderBomId): Asks for confirmation and then deletes a BOM entry.
ExportDispatchedToExcel(name) and ExportDetailedToExcel(name): Exports BOM data to Excel in different formats.
Utilities:
isLoadingAdd(), isLoadingRemove(): Presumably, these would show and hide a loading spinner, but their implementations aren't provided.
toast(): Likely shows a notification or message to the user, but its implementation isn't given.
confirmDelete(): Shows a confirmation prompt to the user before deleting.
DOM Manipulations:
A lot of dynamic content is added to the DOM, especially tables using the jQuery append method.
Ajax Calls:
Several fetch and jQuery $.ajax calls to interact with the server, fetch data, or perform CRUD operations.
UI Feedback:
Various parts of the code provide feedback to the user using modals, toast notifications, and changing the state of UI elements.
Possible Improvements:
Code Modularization: The code can be split into smaller, more focused functions for clarity and maintainability.
Error Handling: More robust error handling can be added, especially for AJAX calls.
Duplication: The two functions ExportDispatchedToExcel and ExportDetailedToExcel have duplicated code, which can be refactored.
Comments: More comments can be added to explain the purpose and behavior of functions and complex code segments.
Use of Modern ES6+ Features: The code can benefit from ES6+ features like arrow functions, async/await, etc., for better readability and structure.
The code in order.edit.header.js. Here's a summary and description of its main functionalities:
Initialization:
When the document is ready, the script performs the following:
Assigns an index to each orderConfig in the orderConfigs array.
Adds event listeners to the change events of #Product and #SubProduct dropdowns to set their respective dropdowns.
Initializes the orderListTable with the DataTable library with specific settings.
Adds event listeners to the click events of #btnAddProduct, #btnSubmit, and #btnRegenerate.
Update Order (onUpdateOrder function):
This function is responsible for sending the updated order data to the server.
It gathers all necessary data from the form (Order ID, Order Number, Project Name, etc.).
Makes an API call (POST request) to /api/Orders/ with the order ID and updates the order with the gathered data.
Shows a success or error message based on the response.
Regenerate Order (onRegenerateOrder function):
This function sends a request to regenerate an order.
It sends an API call (POST request) to /api/Orders/Regenerate/ with the order ID.
Shows a success message and reloads the page or shows an error message based on the response.
Add to Selected Order Config (addToSelectedOrderConfig function):
This function is responsible for adding a product configuration to the order.
It fetches data from the product form (Product, SubProduct, Width, etc.).
Checks if the selected configuration already exists in the orderConfigs array.
If it exists, it updates the quantity; if not, it pushes a new configuration to the array.
Updates the orderListTable accordingly.
Remove Order Config (removeOrderConfig function):
Removes a selected product configuration from the order.
It finds the configuration in the orderConfigs array using the OrderConfigId and removes it.
Also removes the respective row from the orderListTable.
Set Dropdown Functions:
setSubGroupDropdown: Updates the #SubProduct dropdown based on the selected product.
setParameterDropdown: Updates the parameters dropdowns (Width, Length, Grid, Level) based on the selected product and subproduct.
setSingleParameterDropdown: A utility function that updates a specific parameter dropdown.
Miscellaneous:
There are some commented-out lines and functions (like removeOrderConfig that takes orderConfigId and rowCount as arguments).
Error handling is managed by the showError function, which shows an error toast.
The DataTable is used to manage and display the order list.
Overall, the script is structured to manage product configurations in an order. It provides functionalities to add, update, regenerate, and remove configurations, and dynamically updates the form dropdowns based on user selections.
The code you've shared seems to be from the index page of an order management system. Here's a breakdown of the main functionalities:
Initialization:
Upon document readiness, the script performs the following:
Setups the DataTable for the orders list with specific settings, such as scrollable viewport, state-saving, custom length menu, and export buttons (PDF, Excel, CSV, Print).
Defines column rendering functions. For instance, the first column shows a checkbox for selecting an order, the second column contains the order's ID (hidden), and the third column contains a link to edit the order.
Appends a 'bulk actions' dropdown to the DataTable. This dropdown allows users to delete multiple orders at once, and its visibility depends on the user's role.
Appends an 'Add Order' button next to the search filter.
Export Options:
The DataTable provides options for exporting data. When exporting, the script checks if specific rows are selected. If no rows are selected, all visible rows are exported; otherwise, only selected rows are exported.
Bulk Deletion:
Users can select multiple orders using the checkboxes.
The #bulk-delete-orders click event confirms with the user before deletion. Depending on the user's choice, it can either soft delete or hard delete the selected orders.
The deletion action makes an API call to either /api/Orders/DeleteOrders or /api/Orders/HardDeleteOrders based on the type of deletion.
Order Selection:
The onSelectOrder function is triggered when a checkbox is clicked. This function manages the selectedOrderIds array, which tracks the IDs of selected orders.
addToSelectedOrder and removeSelectedOrder are utility functions that manage the addition and removal of order IDs from the selectedOrderIds array.
Miscellaneous:
There's a global variable selectedOrderIds which keeps track of all the currently selected order IDs.
There are helper functions for manipulating this list (addToSelectedOrder and removeSelectedOrder).
Some dynamic UI modifications are performed, like appending the 'Add Order' button and the 'bulk actions' dropdown.
In summary, this script is focused on the display and management of orders on an index page. It provides functionalities for viewing, selecting, bulk deleting, and navigating to individual order edit pages. The DataTable library enhances the table with features like pagination, search, and export options.
The code represents the OrderApiController, which is an API controller responsible for operations related to Orders in the KlausBOM system. I'll break down the structure and functionality of this controller:
1. Namespaces and Dependencies:
using statements include dependencies for authorization, domain entities, DTOs (Data Transfer Objects), services, and utility functions.
2. Class Declaration and Attributes:
[Route("api/Orders")]: Sets the base route for all methods in this controller to /api/Orders.
[ApiController]: Specifies that the class should be treated as an API controller with some specific behaviors.
3. Fields:
orderServices and productConfigServices: Private instances of service classes. These services presumably contain business logic and interact with the database.
4. Constructor:
The constructor takes an IUnitOfWork parameter named work. This is a common pattern for dependency injection and likely represents a unit of work pattern, which is used to batch multiple operations into a single transaction.
The constructor initializes orderServices and productConfigServices with this unit of work.
5. API Endpoints:
CreateOrder:
Accepts a POST request without additional parameters in the route.
Takes in an OrderCreateEditDto object from the request body.
Creates a new order using orderServices.
Returns a success message or a generated error message.
UpdateOrder:
Accepts a POST request with an orderId parameter in the route.
Updates an existing order using orderServices.
Validates the OrderId in the DTO against the orderId in the route.
Returns a success message or a generated error message.
RegenerateOrderBom:
Similar to UpdateOrder but focuses on regenerating an Order's Bill of Materials (BOM).
GetOrderDetails:
Accepts a GET request with an orderId parameter.
Fetches product configurations and order details.
Iterates through order configurations to build a list of OrderConfigViewModel items.
Returns this list or a generated error message.
DeleteParts:
Accepts a POST request.
Deletes multiple orders based on a list of orderIds from the request body.
Returns a success message or a generated error message.
HardDeleteOrders:
Similar to DeleteParts, but likely performs a hard delete operation (completely removing records from the database).
6. Attributes for Authorization:
Many endpoints use the [KlausAuthorize] attribute, which likely provides custom authorization functionality.
This attribute takes parameters for module and feature, which specify the required permissions to execute the method.
7. Error Handling:
Each endpoint is wrapped in a try-catch block.
Exceptions are caught and transformed into a custom error message using ex.GenerateErrorMessage().
This approach ensures that detailed exception information isn't leaked to clients while still providing a helpful error message.
8. Validation:
Before performing operations, there's validation (e.g., checking if DTO's OrderId matches the route's orderId).
Validation helps in ensuring data integrity and protecting against potential misuse or incorrect API calls.
Implications:
Separation of Concerns: The controller delegates business logic and data operations to service classes, keeping the controller focused on handling HTTP requests and responses.
Error Handling: A consistent approach to error handling provides a uniform response to clients when things go wrong.
Authorization: The use of custom attributes suggests a role-based or permission-based authorization system in place.
In summary, OrderApiController is a well-organized API controller focusing on CRUD operations related to Orders. It efficiently handles HTTP requests, delegates heavy operations to services, and ensures data validation and user authorization.
The OrderBom/Edit.cshtml Razor view provides a UI for editing or updating the Bill of Materials (BOM) parts for a specific order in an ASP.NET Core MVC application. Let's dissect the main elements:
1. Directives, Model Declaration, and Layout:
Using the @using directive, the view imports relevant namespaces.
The model for this view is declared as OrderBomCreateEditDto.
Layout for this view is set to ~/Views/Shared/_Layout.cshtml, meaning this view will inherit a master layout.
Breadcrumb navigation is set up using the ViewData["Breadcrumb"].
2. Styles Section:
A CSS file, orderbom.edit.css, is linked to style the page elements.
3. Error Handling:
If there's an error message stored in ViewData["Error"], it gets displayed as a red alert at the top of the page.
4. Order BOM Edit Form:
A form is defined with the ID edit-order-bom-form to capture updates to the BOM part details.
Inside the form:
Hidden input fields store the order ID, order BOM ID, and a boolean flag indicating if the BOM part has a child.
Various input fields and dropdowns allow users to view and edit attributes such as part number, part description, drawing number, unit of measure (UOM), part type, part position, quantity per unit, and total quantity.
If the BOM part isn't order-specific and has a child, the part number can't be updated and is displayed as read-only. Otherwise, it's a dropdown allowing selection from available parts.
A submit button lets users save the updates.
5. Scripts Section:
A JavaScript variable named partList is defined and initialized with a serialized list of parts.
An external JavaScript file, orderbom.edit.js, is also linked to the page. This script presumably contains the necessary JavaScript functions to manage the behavior and interactions on this page.
Summary:
This view provides an interface for users to edit details of a BOM part associated with an order. The form is laid out clearly with labeled input fields, making it user-friendly. The integration of scripts suggests that there are interactive elements on the page, perhaps to validate inputs or provide dynamic behavior based on user choices. The presence of the breadcrumb navigation helps users understand their position within the application and navigate easily.
The code you've shared seems to be from the edit page of an order bill of materials (BOM) system. Here's a breakdown of its functionalities:
Initialization:
Upon document readiness, the script sets up an event listener for the change event on the #PartId dropdown. When the value of this dropdown changes, the setPartDetails function is invoked.
Setting Part Details:
The setPartDetails function is the main functionality of this script.
When a user selects a part using the #PartId dropdown, this function:
Retrieves the selected part's ID.
Finds the corresponding part details from the partList (presumably a global variable or a variable defined elsewhere in the full script).
Populates various input fields (#PartName, #Specification, #DrawingNumber, #RefNumber, #InfoWorldNumber, #Uom, #PartType) with the relevant details from the selected part.
It seems this function is designed to auto-fill the part details based on the selected part ID, thus reducing manual input and potential mistakes.
In summary, this script is focused on helping the user auto-fill details of a part when editing an order's BOM. When a part is selected, its details are fetched from the partList and populated in the corresponding fields, making the edit process faster and more accurate.
From the initial glance at the OrderBomApiController.cs file, it appears to be a .NET Core API controller related to Order BOM (Bill of Materials). Here's what we can infer:
Namespace and Dependencies:
The controller resides in the namespace KlausBOM.Controllers.Api.Order.
Several namespaces are imported which indicates the controller makes use of various services, utilities, DTOs (Data Transfer Objects), domain classes, and other functionalities. Some of the namespaces like KlausBOM.ExcelHelpers and NPOI.XSSF.UserModel suggest Excel processing capabilities.
Controller Declaration:
The API controller is named OrderBomApiController and inherits from ControllerBase.
It has been decorated with the route attribute [Route("api/OrderBoms")], which means that the base URL for accessing the endpoints in this controller will likely be yourdomain.com/api/OrderBoms.
Member Variables:
Several services seem to be defined in the controller such as OrderBomServices, OrderServices, UserServices, ProductConfigServices, and OrderBomChildPartServices.
There's a static variable _env of type IWebHostEnvironment, indicating possible interactions with the web hosting environment.
Column Mappings:
A dictionary named bomChildColumnMapping maps certain keys to their display names (probably for Excel export based on the imported namespaces and the dictionary keys/values).
This code snippet showcases the beginning structure of the OrderBomApiController class, which serves as an API controller for managing Order Bills of Materials (BOM).
Here's a breakdown:
Attributes:
[Route("api/OrderBoms")]: This attribute defines the base route for all the methods inside this API controller, which is /api/OrderBoms.
[ApiController]: This attribute classifies the class as an API controller, providing it with specific behaviors suitable for a web API.
Fields:
orderBomServices, orderServices, userServices, productConfigServices, and orderBomChildPartServices: These are private fields that seem to represent services that the API controller uses to interact with the underlying data or business logic.
_env: This is a static field of type IWebHostEnvironment. This interface provides information about the web hosting environment an application is running in. Given that it's static, it might be set in a static context (like a static constructor or initializer) which isn't shown here. It is often used for retrieving environment-specific settings or file paths.
MappingColumns Region:
This region contains two dictionaries, bomChildColumnMapping and bomColumnMapping, which map internal or database column names to more user-friendly display names. These mappings are likely used when generating reports or output that need to be user-friendly.
bomChildColumnMapping: Maps columns related to child parts of a BOM.
bomColumnMapping: Maps columns for the main BOM.
The commented-out mappings (e.g., //{ "OrderBomId", "OrderBomId" }) suggest these were once considered but are currently not in use.
Implications:
This controller probably deals with CRUD operations for Order BOMs.
The use of services suggests a separation of concerns, where the controller handles HTTP requests and responses while the services handle data operations and business logic.
The mapping dictionaries will likely be used in methods that create user-friendly reports or exports, translating internal names to more readable column names.
The provided code snippet is a partial definition of the OrderBomApiController class. This class inherits from ControllerBase and is annotated to serve as an API controller, primarily handling operations related to Order Bills of Materials (BOM).
Analysis:
Attributes:
[Route("api/OrderBoms")]: This attribute specifies that the base route for all endpoints in this controller will be /api/OrderBoms.
[ApiController]: This attribute denotes that the class should be treated as a controller that responds to web API requests.
Fields:
Service Fields: The class has various service fields like orderBomServices, orderServices, userServices, productConfigServices, and orderBomChildPartServices. These fields represent different services that are likely used to interact with the database or handle business logic.
_env: A static field representing the web hosting environment. It's often used to get environment-specific settings or paths.
MappingColumns Region:
This region defines two dictionaries that map internal or database column names to more user-friendly or display-oriented names.
bomChildColumnMapping: Maps database columns for child parts in a Bill of Materials (BOM) to their user-friendly names.
bomColumnMapping: Maps database columns for the main BOM to their user-friendly names.
Observations:
The dictionaries in the MappingColumns region seem to serve as a bridge between database column names and the names that are probably used in some front-end display or export functionality (like generating an Excel sheet).
The commented-out lines (e.g., //{ "QuantityPerMachine", "Qty" } and //{ "OrderBomId", "OrderBomId" }) in the dictionaries suggest that these mappings were considered at some point but are currently not in use.
The services are likely injected through the constructor, which isn't shown in this snippet, and are used to perform various operations on data.
This #region ColumnNames Lists provides a definition for a private list named columns. This list is essentially a collection of column names.
Analysis:
List Name: columns
Type: List<string>
Purpose: Represents column headers or names which are likely used for a DataTable structure or an Excel sheet.
Content:
The list contains the following column names in the specified order:
Part No.
BOM Line
Item Description
Specification
Part Position
Drawing No.
Ref. No.
InfoWorld No.
UOM (usually stands for Unit of Measurement)
Qty (short for Quantity)
Unit Weight
Total Weight
Total Qty
Part Rate
Total Cost
Type
Potential Usage:
Given its name and the names of the columns, the columns list is likely used when constructing a DataTable or an Excel sheet related to Bill of Materials (BOM) or some parts inventory. The columns capture a variety of attributes related to parts, from their identification numbers to their specifications, quantities, weights, costs, and other related attributes.
This list serves as a reference for creating, manipulating, or exporting data structures, ensuring consistency in the columns used across different parts of the application.
IUnitOfWork work: An interface representing a unit of work. This pattern typically provides the ability to make multiple database operations in a single transaction.
IWebHostEnvironment env: Provides information about the web hosting environment an application is running in.
Body Description:
Initializes the _env private variable with the provided env parameter.
Initializes multiple service objects (userServices, productConfigServices, orderServices, orderBomServices, orderBomChildPartServices) using the provided work parameter.
Provides an endpoint to retrieve all available BOM parts for a specific order.
Functional Breakdown:
Calls the GetAvailableOrderBomPartAsync method of the orderBomServices object to retrieve all available BOM parts for the provided orderId.
Returns the retrieved BOM parts with a 200 OK status.
If an exception occurs, a 500 Internal Server Error status is returned, along with an error message generated from the exception.
Overall Summary:
The OrderBomApiController class provides API endpoints related to Order BOM operations.
The class constructor initializes multiple services that facilitate operations related to users, product configurations, orders, BOMs, and BOM child parts.
The methods in the class handle retrieval operations related to BOMs, such as fetching BOM items for a specific order, retrieving child parts for a specific BOM item, and getting available BOM parts for a specific order.
[HttpPost("{orderId}")]: This attribute indicates that the method responds to HTTP POST requests and expects the orderId as part of the URL. An example request to this endpoint could look like /1234 where 1234 is the orderId.
[KlausAuthorize(module: PermissionModule.ORDER, feature: PermissionFeature.CREATE)]: This custom authorization attribute ensures that the user or role invoking this method has the necessary permissions, specifically for the ORDER module and the CREATE feature.
Parameters:
string orderId: Represents the ID of the Order to which the BOM part is to be added.
OrderBomCreateEditDto orderBom: Represents the data transfer object containing the details of the BOM part that is to be added.
Return Type:
Task<IActionResult>: Represents an asynchronous operation that returns an IActionResult, used to produce an HTTP response.
Description:
The method aims to add a BOM (Bill of Materials) part to a specific order based on the given orderId.
Functional Breakdown:
Input Validation:
It checks if the orderId parameter matches the OrderId property of the orderBom object.
If they don't match, an exception is thrown with the message "Invalid request! Please check again...".
Add Operation:
Calls the AddOrderBomPartAsync method of the orderBomServices object, passing the orderBom DTO. This likely adds the BOM part to the database or updates existing records.
Response Formation:
If the add operation is successful, the method returns a 200 OK status code with a message indicating the successful addition of the BOM part.
If any exception occurs during the process, a 500 Internal Server Error status code is returned, accompanied by an error message generated from the exception.
Purpose:
This method provides an API endpoint to allow clients to add or update a BOM part associated with a specific order. It ensures the validity of the request, performs the add/update operation, and then returns an appropriate HTTP response to the client.
In essence, the AddOrderBomPart method is designed to facilitate the addition or update of BOM parts associated with specific orders, ensuring data integrity by checking the consistency between the provided orderId and the OrderId property of the orderBom DTO.
[HttpPost("Delete/{orderBomId}")]: This attribute indicates that the method responds to HTTP POST requests and expects the orderBomId as a part of the URL. For example, a request to this endpoint might look like /Delete/1234 where 1234 is the orderBomId.
[KlausAuthorize(module: PermissionModule.ORDER, feature: PermissionFeature.DELETE)]: This custom authorization attribute ensures that the user or role invoking this method has the necessary permissions, specifically for the ORDER module and the DELETE feature.
Parameters:
string orderBomId: Represents the ID of the Order BOM that is intended to be deleted.
Return Type:
Task<IActionResult>: Represents an asynchronous operation that returns an IActionResult, used to produce an HTTP response.
Description:
The method is designed to perform a delete operation on a single Order BOM identified by its ID.
Functional Breakdown:
Delete Operation:
Calls the DeleteOrderBomAsync method of the orderBomServices object, passing the orderBomId and a boolean flag set to false. This boolean likely indicates that it's a hard delete operation (permanently removes the data).
Response Formation:
If the delete operation is successful, the method returns a 200 OK status code with a message indicating the successful deletion of the Order BOM.
If any exception occurs during the process, a 500 Internal Server Error status code is returned, along with an error message generated from the exception.
Purpose:
This method provides an API endpoint to allow clients to request a hard delete operation on a specific Order BOM. It ensures the validity of the request, performs the delete operation, and then returns an appropriate HTTP response to the client.
In essence, while the previous methods (HardDeleteOrderBoms and DeleteOrderBoms) allowed for bulk deletion of Order BOMs by accepting a collection of IDs, the DeleteOrderBom method focuses on the deletion of a single Order BOM based on its specific ID.
[KlausAuthorize(module: PermissionModule.ORDER, feature: PermissionFeature.SOFT_DELETE)]: This custom authorization attribute likely ensures that the user or role invoking this method has the necessary permissions, specifically for the ORDER module and the SOFT_DELETE feature.
[HttpPost("DeleteOrderBoms")]: Indicates that this method responds to HTTP POST requests at the "DeleteOrderBoms" endpoint.
Parameters:
IEnumerable<string> orderBomIds: Represents a collection of Order BOM IDs intended to be deleted. The [FromBody] attribute indicates that these IDs should be part of the request body.
Return Type:
Task<IActionResult>: Represents an asynchronous operation that returns an IActionResult, which is used to produce an HTTP response.
Description:
The method is designed to perform a soft delete operation on a collection of Order BOMs identified by their IDs.
Functional Breakdown:
Input Validation:
It checks if orderBomIds is null or if its count is zero.
If either condition is met, an exception is thrown with the message "No Order BOM to Delete!!".
Delete Operation:
Calls the DeleteBulkOrderBomsAsync method of the orderBomServices object, passing only the orderBomIds. Unlike the HardDeleteOrderBoms method, this one doesn't pass the boolean flag, implying that the default behavior of the service method might be a soft delete.
Response Formation:
If the delete operation is successful, the method returns a 200 OK status code with a message indicating the successful deletion of the Order BOMs.
If any exception occurs during the process, a 500 Internal Server Error status code is returned, along with an error message generated from the exception.
Purpose:
This method provides an API endpoint to allow clients to request a soft delete operation on a collection of Order BOMs. It ensures the validity of the request, performs the delete operation, and then returns an appropriate HTTP response to the client.
Comparison with HardDeleteOrderBoms:
Both methods are quite similar in structure and functionality. The primary distinction is in the type of delete operation they perform. While HardDeleteOrderBoms seemingly performs a hard delete (permanent removal), DeleteOrderBoms likely performs a soft delete, which typically involves marking records as deleted without actually removing them from the database. The specific behavior of the delete operations would be determined by the implementation of the DeleteBulkOrderBomsAsync method in the orderBomServices object.
[KlausAuthorize(module: PermissionModule.ORDER, feature: PermissionFeature.DELETE)]: This attribute is presumably a custom authorization attribute. It likely ensures that the user or role invoking this method has the necessary permissions, specifically for the ORDER module and the DELETE feature.
[HttpPost("HardDeleteOrderBoms")]: This attribute denotes that the method responds to HTTP POST requests at the "HardDeleteOrderBoms" endpoint.
Parameters:
IEnumerable<string> orderBomIds: This represents a collection of Order BOM IDs that are intended to be deleted. The [FromBody] attribute suggests that these IDs are expected to be part of the request body.
Return Type:
Task<IActionResult>: Represents an asynchronous operation that returns an IActionResult, which is used to produce an HTTP response.
Description:
The method is designed to perform a hard delete operation on a collection of Order BOMs identified by their IDs.
Functional Breakdown:
Input Validation:
Checks if orderBomIds is null or if its count is zero.
If either condition is met, an exception is thrown with the message "No Order BOM to Delete!!".
Delete Operation:
Calls the DeleteBulkOrderBomsAsync method of the orderBomServices object, passing the orderBomIds and a boolean flag false (likely indicating that it's a hard delete operation, as opposed to a soft delete).
Response Formation:
If the delete operation is successful, the method returns a 200 OK status code with a message indicating the successful deletion of the Order BOMs.
If any exception occurs during the process, a 500 Internal Server Error status code is returned, along with an error message generated from the exception. The method GenerateErrorMessage is presumably an extension or helper method that produces a user-friendly error message based on the exception.
Purpose:
This method provides an API endpoint to allow clients to request a hard delete operation on a collection of Order BOMs. It ensures the validity of the request, performs the delete operation, and then returns an appropriate HTTP response to the client.
Task<List<OrderConfigViewModel>>: Represents an asynchronous task that will return a list of OrderConfigViewModel objects.
Description:
This method retrieves the detailed configuration of an order and returns a list of view models (OrderConfigViewModel) that represent the order's configurations.
Functional Breakdown:
Data Retrieval:
Retrieves all released product configurations.
Retrieves the order details for the given orderId.
Extracts the configurations associated with the order.
Model Population:
Initializes an empty list of OrderConfigViewModel.
Iterates through each configuration associated with the order.
For each configuration, it identifies the associated product configuration, grid, level, width, and length details.
Populates the OrderConfigViewModel with the extracted details and appends it to the list.
The counter (SrNo) is incremented for each iteration, providing a sequence number for the view model.
Exception Handling:
If any exception occurs during the process, the method returns null.
Purpose:
This method is designed to fetch the detailed configurations for a specific order and map them to a view model (OrderConfigViewModel). This view model provides a structured representation of the order's configurations, making it easier to work with in other parts of the application or for display purposes.
The OrderConfigViewModel is likely a simple data structure or DTO (Data Transfer Object) that holds properties such as SrNo, Product, SubProduct, Width, Length, Grid, Level, and Quantity.
Task<List<OrderConfigViewModel>>: Represents an asynchronous task that will return a list of OrderConfigViewModel objects.
Description:
This method retrieves the detailed configuration of an order and returns a list of view models (OrderConfigViewModel) that represent the order's configurations.
Functional Breakdown:
Data Retrieval:
Retrieves all released product configurations.
Retrieves the order details for the given orderId.
Extracts the configurations associated with the order.
Model Population:
Initializes an empty list of OrderConfigViewModel.
Iterates through each configuration associated with the order.
For each configuration, it identifies the associated product configuration, grid, level, width, and length details.
Populates the OrderConfigViewModel with the extracted details and appends it to the list.
The counter (SrNo) is incremented for each iteration, providing a sequence number for the view model.
Exception Handling:
If any exception occurs during the process, the method returns null.
Purpose:
This method is designed to fetch the detailed configurations for a specific order and map them to a view model (OrderConfigViewModel). This view model provides a structured representation of the order's configurations, making it easier to work with in other parts of the application or for display purposes.
The OrderConfigViewModel is likely a simple data structure or DTO (Data Transfer Object) that holds properties such as SrNo, Product, SubProduct, Width, Length, Grid, Level, and Quantity.
[HttpGet("ExportDispatchedToExcel/{orderid}")]public ActionResult ExportDispatchedToExcel(stringorderid){varmain= orderBomServices.GetOrderBomsAsync(orderid).Result.OrderBy(x => x.PartGroupName);varcategory= main.Select(x => x.PartGroupName).Distinct().ToList();varorderIds= main.Select(x => x.OrderBomId).ToList();varorderDetails= orderServices.GetOrderAsync(orderid).Result;varuser= userServices.GetUserAsync(orderDetails.AddedBy).Result;varmainTable= ConvertToDataTable.ToDataTable(main);varexportTable=new DataTable();
AddColumnsToDataTable(exportTable, columns);
CopyDataTableRows(mainTable, exportTable, bomColumnMapping);//Create a new Excel workbook and worksheetXSSFWorkbookworkbook=new XSSFWorkbook();ISheetworksheet= workbook.CreateSheet("DispatchBOM");
#region Styles
InsertLogo(workbook, worksheet,"Klaus Logo.png");varinfoStyle= workbook.CreateCellStyle();
infoStyle.BorderTop = BorderStyle.Thick;
infoStyle.TopBorderColor = IndexedColors.Black.Index;varinforRow= worksheet.CreateRow(4);for(inti=0;i<16;i++){ICellinfoCell= inforRow.CreateCell(i);
infoCell.CellStyle =infoStyle;}vartitleStyle= CreateCellStyle(workbook,null, IndexedColors.Black,(short)FontBoldWeight.Bold, HorizontalAlignment.Left);varorderDetailsStyle= CreateCellStyle(workbook,null, IndexedColors.Black,(short)FontBoldWeight.Bold, HorizontalAlignment.Left);//Create a new style for the header row varheaderStyle= CreateCellStyle(workbook,newbyte[]{255,147,1}, IndexedColors.Black,(short)FontBoldWeight.Bold, HorizontalAlignment.Left);//Create a new style for the data rows vardataStyle= CreateCellStyle(workbook,newbyte[]{252,228,214}, IndexedColors.Black,(short)FontBoldWeight.None, HorizontalAlignment.Left);varchildDataStyle= CreateCellStyle(workbook,newbyte[]{217,217,217}, IndexedColors.Black,(short)FontBoldWeight.None, HorizontalAlignment.Left);//Create a new style for the ParentID and ChildID cells// ICellStyle navigationStyle = CreateCellStyle(workbook, new byte[] { 231, 231, 44 }, IndexedColors.Black,// (short)FontBoldWeight.Bold, HorizontalAlignment.Center);// for groupvargroupStyle= CreateCellStyle(workbook,newbyte[]{243,176,132}, IndexedColors.Black,(short)FontBoldWeight.Bold, HorizontalAlignment.Left);
#endregion
#region Info Order Details
string[]orderData={$"Order Number : {orderDetails.OrderNumber}",$"Project Name : {orderDetails.ProjectName}",$"Prepared By : {user.FirstName}{user.LastName}",$"Project City : {orderDetails.City}",$"Customer Name : {orderDetails.Customer}",$"Release Date : {orderDetails.ReleaseDate}",$"Car Space Quantity : {orderDetails.CarSpacesQuantity}"};IRowtitleRow= worksheet.CreateRow(0);ICelltitleCell= titleRow.CreateCell(3);
titleCell.SetCellValue($"Dispatch BOM : {orderDetails.OrderNumber}");
titleCell.CellStyle =titleStyle;IRowoneInfo= worksheet.CreateRow(1);varinfoOrderIndex=0;for(inti=2;i<5;i++){ICellocell= oneInfo.CreateCell(i);
ocell.SetCellValue(orderData[infoOrderIndex]);infoOrderIndex++;
ocell.CellStyle =orderDetailsStyle;}IRowtwoInfo= worksheet.CreateRow(2);for(inti=2;i<5;i++){ICellocell= twoInfo.CreateCell(i);
ocell.SetCellValue(orderData[infoOrderIndex]);infoOrderIndex++;
ocell.CellStyle =orderDetailsStyle;}IRowtreeInfo= worksheet.CreateRow(3);for(inti=2;i<3;i++){ICellocell= treeInfo.CreateCell(i);
ocell.SetCellValue(orderData[infoOrderIndex]);
ocell.CellStyle =orderDetailsStyle;}
#endregion
#region Product List
varproducts= GetOrderDetails(orderid).Result;varproductTable= ConvertToDataTable.ToDataTable(products);IRowproductHeaderRow= worksheet.CreateRow(6);intpindex=1;for(inti=0;i< productTable.Columns.Count;i++){ICellcell= productHeaderRow.CreateCell(pindex);
cell.SetCellValue(productTable.Columns[i].ColumnName);
cell.CellStyle =headerStyle;pindex++;}pindex=1;varproductindex=7;for(inti=0;i< productTable.Rows.Count;i++){IRowpRow= worksheet.CreateRow(productindex);DataRowpdRow= productTable.Rows[i];for(intj=0;j< productTable.Columns.Count;j++){ICellcell= pRow.CreateCell(pindex);
cell.SetCellValue(pdRow[j].ToString());
cell.CellStyle =dataStyle;pindex++;}productindex++;pindex=1;}
#endregion
#region Bom Order List
intbomorderHeaderRowIndex=productindex+1;//Add header row to the worksheetIRowheaderRow= worksheet.CreateRow(bomorderHeaderRowIndex);for(inti=0;i< exportTable.Columns.Count;i++){ICellcell= headerRow.CreateCell(i);
cell.SetCellValue(exportTable.Columns[i].ColumnName);
cell.CellStyle =headerStyle;}varccounter=0;stringprevPartGroupName=null;varindex=bomorderHeaderRowIndex+1;for(inti=0;i< exportTable.Rows.Count;i++){DataRowrow= exportTable.Rows[i];varpartGroupName= mainTable.Rows[i]["PartGroupName"].ToString();if(prevPartGroupName!=partGroupName){IRowgroupRow= worksheet.CreateRow(index);for(intj=0;j<16;j++){ICellgcell= groupRow.CreateCell(j);
gcell.CellStyle =groupStyle;}ICellgCell= groupRow.GetCell(0)?? groupRow.CreateCell(0);
gCell.SetCellValue(category[ccounter]);//if (prevPartGroupName == null)//{ccounter++;//}index++;prevPartGroupName=partGroupName;}IRowdataRow= worksheet.CreateRow(index);for(intj=0;j< exportTable.Columns.Count;j++){ICellcell= dataRow.CreateCell(j);
cell.SetCellValue(row[j].ToString());
cell.CellStyle =dataStyle;if(exportTable.Columns[j].ColumnName =="OrderBomId"&& row["OrderBomId"]!= DBNull.Value){
#region Commented Code
#endregion
}}index++;}
#endregion
AutoCorrectColumnSizes(worksheet, bomorderHeaderRowIndex);// Generate Excel FileMemoryStreamoriginalStream=new MemoryStream();
workbook.Write(originalStream);MemoryStreamns=new MemoryStream(originalStream.ToArray());
originalStream.Dispose();// download excel filestringfileName="DispatchBOMExport.xlsx";return File(ns.ToArray(),"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
fileName);}
Here's an in-depth analysis of the ExportDispatchedToExcel method:
Description:
This method is responsible for exporting the Bill Of Material (BOM) data for a dispatched order to an Excel file.
Functional Breakdown:
Data Retrieval:
Retrieves the main BOM details for the given orderid and sorts them by PartGroupName.
Extracts distinct PartGroupName values and a list of OrderBomId values.
Fetches details about the order and the user who added the order.
Data Table Initialization:
The main BOM data is converted to a DataTable named mainTable.
An empty DataTable named exportTable is initialized.
Columns are added to exportTable, and rows from mainTable are copied to it.
Excel Workbook Initialization:
A new Excel workbook and worksheet are created.
Styles for various cell types (info, title, header, data, etc.) are defined. The method uses helper functions like CreateCellStyle and InsertLogo to set these styles.
Order Details Insertion:
Specific order details like order number, project name, user details, etc., are set in specific cells of the worksheet.
Product List Insertion:
Product details associated with the order are fetched and converted to a DataTable.
The product data is then inserted into the worksheet with appropriate styles.
BOM Order List Insertion:
The BOM details from exportTable are iterated and inserted into the worksheet.
For each BOM item, the method checks for an associated OrderBomId, but there's no further action within this context (there's commented-out code which might have been intended for this).
Auto-correction of Column Sizes:
The AutoCorrectColumnSizes function is invoked to adjust the column widths based on content.
Excel File Generation:
The constructed Excel workbook is written to a MemoryStream.
The stream is then converted to an array, which is returned as a file with the name "DispatchBOMExport.xlsx".
Purpose:
This method provides functionality to generate an Excel report of the Bill of Materials (BOM) for a dispatched order. The resulting Excel file contains information about the order, products associated with the order, and the BOM details.
[HttpGet("ExportDetailedToExcel/{orderid}")]public ActionResult ExportDetailedToExcel(stringorderid){varmain= orderBomServices.GetOrderBomsAsync(orderid).Result.OrderBy(x => x.PartGroupName);varcategory= main.Select(x => x.PartGroupName).Distinct().ToList();varorderIds= main.Select(x => x.OrderBomId).ToList();varorderDetails= orderServices.GetOrderAsync(orderid).Result;varuser= userServices.GetUserAsync(orderDetails.AddedBy).Result;varmainTable= ConvertToDataTable.ToDataTable(main);varexportTable=new DataTable();
AddColumnsToDataTable(exportTable, columns);
CopyDataTableRows(mainTable, exportTable, bomColumnMapping);//Create a new Excel workbook and worksheetXSSFWorkbookworkbook=new XSSFWorkbook();ISheetworksheet= workbook.CreateSheet("DetailedLevelBOM");
#region Styles
InsertLogo(workbook, worksheet,"Klaus Logo.png");varinfoStyle= workbook.CreateCellStyle();
infoStyle.BorderTop = BorderStyle.Thick;
infoStyle.TopBorderColor = IndexedColors.Black.Index;varinforRow= worksheet.CreateRow(4);for(inti=0;i<16;i++){ICellinfoCell= inforRow.CreateCell(i);
infoCell.CellStyle =infoStyle;}vartitleStyle= CreateCellStyle(workbook,null, IndexedColors.Black,(short)FontBoldWeight.Bold, HorizontalAlignment.Left);varorderDetailsStyle= CreateCellStyle(workbook,null, IndexedColors.Black,(short)FontBoldWeight.Bold, HorizontalAlignment.Left);//Create a new style for the header row varheaderStyle= CreateCellStyle(workbook,newbyte[]{255,147,1}, IndexedColors.Black,(short)FontBoldWeight.Bold, HorizontalAlignment.Left);//Create a new style for the data rows vardataStyle= CreateCellStyle(workbook,newbyte[]{252,228,214}, IndexedColors.Black,(short)FontBoldWeight.None, HorizontalAlignment.Left);varchildDataStyle= CreateCellStyle(workbook,newbyte[]{217,217,217}, IndexedColors.Black,(short)FontBoldWeight.None, HorizontalAlignment.Left);//Create a new style for the ParentID and ChildID cells// ICellStyle navigationStyle = CreateCellStyle(workbook, new byte[] { 231, 231, 44 }, IndexedColors.Black,// (short)FontBoldWeight.Bold, HorizontalAlignment.Center);// for groupvargroupStyle= CreateCellStyle(workbook,newbyte[]{243,176,132}, IndexedColors.Black,(short)FontBoldWeight.Bold, HorizontalAlignment.Left);
#endregion
#region Info Order Details
string[]orderData={$"Order Number : {orderDetails.OrderNumber}",$"Project Name : {orderDetails.ProjectName}",$"Prepared By : {user.FirstName}{user.LastName}",$"Project City : {orderDetails.City}",$"Customer Name : {orderDetails.Customer}",$"Release Date : {orderDetails.ReleaseDate}",$"Car Space Quantity : {orderDetails.CarSpacesQuantity}"};IRowtitleRow= worksheet.CreateRow(0);ICelltitleCell= titleRow.CreateCell(3);
titleCell.SetCellValue($"Detailed BOM : {orderDetails.OrderNumber}");
titleCell.CellStyle =titleStyle;IRowoneInfo= worksheet.CreateRow(1);varinfoOrderIndex=0;for(inti=2;i<5;i++){ICellocell= oneInfo.CreateCell(i);
ocell.SetCellValue(orderData[infoOrderIndex]);infoOrderIndex++;
ocell.CellStyle =orderDetailsStyle;}IRowtwoInfo= worksheet.CreateRow(2);for(inti=2;i<5;i++){ICellocell= twoInfo.CreateCell(i);
ocell.SetCellValue(orderData[infoOrderIndex]);infoOrderIndex++;
ocell.CellStyle =orderDetailsStyle;}IRowtreeInfo= worksheet.CreateRow(3);for(inti=2;i<3;i++){ICellocell= treeInfo.CreateCell(i);
ocell.SetCellValue(orderData[infoOrderIndex]);
ocell.CellStyle =orderDetailsStyle;}
#endregion
#region Product List
varproducts= GetOrderDetails(orderid).Result;varproductTable= ConvertToDataTable.ToDataTable(products);IRowproductHeaderRow= worksheet.CreateRow(6);intpindex=1;for(inti=0;i< productTable.Columns.Count;i++){ICellcell= productHeaderRow.CreateCell(pindex);
cell.SetCellValue(productTable.Columns[i].ColumnName);
cell.CellStyle =headerStyle;pindex++;}pindex=1;varproductindex=7;for(inti=0;i< productTable.Rows.Count;i++){IRowpRow= worksheet.CreateRow(productindex);DataRowpdRow= productTable.Rows[i];for(intj=0;j< productTable.Columns.Count;j++){ICellcell= pRow.CreateCell(pindex);
cell.SetCellValue(pdRow[j].ToString());
cell.CellStyle =dataStyle;pindex++;}productindex++;pindex=1;}
#endregion
#region Bom Order List
intbomorderHeaderRowIndex=productindex+1;//Add header row to the worksheetIRowheaderRow= worksheet.CreateRow(bomorderHeaderRowIndex);for(inti=0;i< exportTable.Columns.Count;i++){ICellcell= headerRow.CreateCell(i);
cell.SetCellValue(exportTable.Columns[i].ColumnName);
cell.CellStyle =headerStyle;}varccounter=0;stringprevPartGroupName=null;varindex=bomorderHeaderRowIndex+1;for(inti=0;i< exportTable.Rows.Count;i++){DataRowrow= exportTable.Rows[i];varpartGroupName= mainTable.Rows[i]["PartGroupName"].ToString();if(prevPartGroupName!=partGroupName){IRowgroupRow= worksheet.CreateRow(index);for(intj=0;j<16;j++){ICellgcell= groupRow.CreateCell(j);
gcell.CellStyle =groupStyle;}ICellgCell= groupRow.GetCell(0)?? groupRow.CreateCell(0);
gCell.SetCellValue(category[ccounter]);//if (prevPartGroupName == null)//{ccounter++;//}index++;prevPartGroupName=partGroupName;}IRowdataRow= worksheet.CreateRow(index);for(intj=0;j< exportTable.Columns.Count;j++){ICellcell= dataRow.CreateCell(j);
cell.SetCellValue(row[j].ToString());
cell.CellStyle =dataStyle;if(exportTable.Columns[j].ColumnName =="OrderBomId"&& row["OrderBomId"]!= DBNull.Value){
#region Commented Code
/* if (exportTable.Columns[j].ColumnName == "OrderBomId" && row["OrderBomId"] != DBNull.Value) { // Childs My Method. string sheetName = row["OrderBomId"].ToString(); var childs = orderBomChildPartServices.GetOrderBomChildPartsAsync(row["OrderBomId"].ToString()) .Result; if (childs.Count() > 0) { var childsTable = ConvertToDataTable.ToDataTable(childs); var exportChildsTable = new DataTable(); AddColumnsToDataTable(exportChildsTable, childColumns); CopyDataTableRows(childsTable, exportChildsTable, bomChildColumnMapping); ISheet childSheet = workbook.CreateSheet(sheetName.Split("-")[0]); IRow childHeaderRow = childSheet.CreateRow(0); for (int c = 0; c < exportChildsTable.Columns.Count; c++) { ICell childCell = childHeaderRow.CreateCell(c); childCell.SetCellValue(exportChildsTable.Columns[c].ColumnName); childCell.CellStyle = headerStyle; childSheet.AutoSizeColumn(c); } for (int c = 0; c < childsTable.Rows.Count; c++) { DataRow childRow = exportChildsTable.Rows[c]; IRow childDataRow = childSheet.CreateRow(c + 1); for (int cc = 0; cc < exportChildsTable.Columns.Count; cc++) { ICell childCell = childDataRow.CreateCell(cc); childCell.SetCellValue(childRow[cc].ToString()); childCell.CellStyle = dataStyle; } } cell.CellStyle = navigationStyle; cell.Hyperlink = workbook.GetCreationHelper().CreateHyperlink(HyperlinkType.Document); cell.Hyperlink.Address = sheetName.Split("-")[0] + "!A1"; } } */
#endregion
}}index++;varchilds= orderBomChildPartServices.GetOrderBomChildPartsAsync(orderIds[i]).Result;if(childs.Count()>0){varchildsTable= ConvertToDataTable.ToDataTable(childs);varexportChildsTable=new DataTable();
AddColumnsToDataTable(exportChildsTable, columns);
CopyDataTableRows(childsTable, exportChildsTable, bomChildColumnMapping);for(intc=0;c< childsTable.Rows.Count;c++){DataRowchildRow= exportChildsTable.Rows[c];IRowchildDataRow= worksheet.CreateRow(index);for(intcc=0;cc< exportChildsTable.Columns.Count;cc++){ICellchildCell= childDataRow.CreateCell(cc);
childCell.SetCellValue(childRow[cc].ToString());
childCell.CellStyle =childDataStyle;}index++;}}}
#endregion
AutoCorrectColumnSizes(worksheet, bomorderHeaderRowIndex);// Generate Excel FileMemoryStreamoriginalStream=new MemoryStream();
workbook.Write(originalStream);MemoryStreamns=new MemoryStream(originalStream.ToArray());
originalStream.Dispose();// download excel filestringfileName="DetailedBOMExport.xlsx";return File(ns.ToArray(),"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
fileName);}
Here's an in-depth analysis of the ExportDetailedToExcel method:
Description:
This method is responsible for exporting detailed Bill Of Material (BOM) data for a given order to an Excel file.
Functional Breakdown:
Data Retrieval:
The method retrieves the main BOM details for the given orderid and sorts them by PartGroupName.
It also retrieves distinct PartGroupName values and a list of OrderBomId values.
Details about the order and the user who added the order are fetched.
Data Table Initialization:
The main BOM data is converted to a DataTable named mainTable.
An empty DataTable named exportTable is initialized.
Columns are added to exportTable, and rows from mainTable are copied to it.
Excel Workbook Initialization:
A new Excel workbook and worksheet are created.
Styles for various cell types (info, title, header, data, etc.) are defined. Notably, the method uses previously analyzed helper functions like CreateCellStyle and InsertLogo to set these styles.
Order Details Insertion:
Specific order details like order number, project name, user details, etc., are set in specific cells of the worksheet.
Product List Insertion:
Product details associated with the order are fetched and converted to a DataTable.
The product data is then inserted into the worksheet with appropriate styles.
BOM Order List Insertion:
The BOM details from exportTable are iterated and inserted into the worksheet.
For each BOM item, associated child parts are retrieved and added to the worksheet.
Auto-correction of Column Sizes:
The AutoCorrectColumnSizes function (analyzed previously) is invoked to adjust the column widths based on content.
Excel File Generation:
The constructed Excel workbook is written to a MemoryStream.
The stream is then converted to an array, which is returned as a file with the name "DetailedBOMExport.xlsx".
Purpose:
This method provides functionality to generate a detailed Excel report of the Bill of Materials (BOM) for a specific order. The resulting Excel file contains information about the order, products associated with the order, and the BOM details, including child parts.
The OrderBomController is an MVC controller in the KlausBOM system. It deals with operations related to the OrderBom entity. Here's an in-depth analysis:
1. Dependencies:
Various namespaces are imported to enable functionalities like custom authorization, domain entities, DTOs (Data Transfer Objects), and services.
2. Class Declaration and Attributes:
[Route("OrderBoms")]: Specifies the base route for all methods in this controller as /OrderBoms.
This controller inherits from the Controller base class, which means it is an MVC controller and not an API controller.
3. Fields:
orderBomServices and orderServices: Private service instances. These services likely contain business logic and interact with the database.
4. Constructor:
Accepts an IUnitOfWork parameter named work. This is a unit of work pattern, which batches multiple operations into a single transaction.
The constructor initializes orderBomServices and orderServices using this unit of work.
5. Actions:
Index:
The simplest action that returns the default view for the controller.
Edit (GET):
Accepts a GET request with an orderBomId parameter.
Retrieves the OrderBom with the specified ID.
If the OrderBom does not exist, it throws an exception.
Retrieves a list of parts available for the order, appending the current part to the list.
Populates the ViewData with the parts list and then returns a View populated with the OrderBomCreateEditDto.
Edit (POST):
Accepts a POST request with an orderBomId and an OrderBomCreateEditDto.
Again, retrieves a list of parts available for the order and appends the current part to the list.
Validates the orderBomId against the DTO's OrderBomId.
Updates the OrderBom using orderBomServices.
If successful, sets a success message in TempData and redirects to the Edit view of the parent Order.
If there's an exception, it sets an error message in ViewData and returns the Edit view populated with the DTO.
6. Authorization:
Custom authorization is used in the form of the [KlausAuthorize] attribute. This attribute specifies the required permissions for executing the method.
7. Error Handling:
Both Edit actions use try-catch blocks to handle exceptions.
If an error occurs, the error message is stored in ViewData and displayed on the View.
8. ViewData and TempData:
ViewData: A dictionary that can pass data from the controller to the view.
TempData: A dictionary that retains information for the duration of a single request. Useful for passing data between actions (e.g., success or error messages).
Implications:
MVC Structure: Unlike an API controller, this controller is designed to interact with views in the MVC framework. It retrieves data, populates models, and returns views.
Error Handling: The consistent approach ensures a smooth user experience by displaying meaningful error messages on the views.
Authorization: Role-based or permission-based authorization is applied to ensure only authorized users can perform certain actions.
Data Retrieval and Manipulation: The controller focuses heavily on data operations, especially related to OrderBom and its associated parts. This includes reading, updating, and organizing data before passing it to the view.
In summary, OrderBomController is a well-structured MVC controller dedicated to operations on OrderBom entities. It integrates smoothly with views, ensuring a seamless user experience.
The OrderController class is an MVC controller in the KlausBOM system that handles operations related to orders. Let's break it down:
1. Dependencies:
Several namespaces are imported, granting functionalities such as custom authorization, domain entities, DTOs (Data Transfer Objects), services, and system utilities like DataTable.
2. Class Declaration and Attributes:
[Route("Orders")]: Specifies the base route for all methods in this controller as /Orders.
This controller inherits from the Controller base class, which means it's an MVC controller and not an API controller.
3. Fields:
The controller contains multiple service instances:
orderServices, productConfigServices, widthServices, gridServices, lengthServices, and levelServices.
These services probably contain business logic and database interactions.
4. Constructor:
Accepts an IUnitOfWork parameter named work. This is a unit of work pattern, which batches multiple operations into a single transaction.
The constructor initializes the service fields using this unit of work.
5. Actions:
Index (GET):
Retrieves a list of orders and constructs a DataTable with various columns to display the orders.
Populates the DataTable with the retrieved orders.
Returns the constructed DataTable to the View.
Create (GET):
Retrieves a list of product configurations.
Organizes the data into two ViewData lists: Products and SubProducts.
Returns a new OrderCreateEditDto to the View.
Edit (GET):
Accepts an orderId parameter.
Retrieves the corresponding order and the list of product configurations.
Organizes the data into two ViewData lists: Products and SubProducts.
Returns the retrieved OrderCreateEditDto to the View.
6. Authorization:
Custom authorization is in place through the [KlausAuthorize] attribute. This ensures that only users with the necessary permissions can access the related actions.
7. Error Handling:
Each action contains a try-catch block for error handling.
If an error occurs, the error message is stored in ViewData and displayed on the View.
8. ViewData:
ViewData: A dictionary that can pass data from the controller to the view. It's used to provide additional data to the view that isn't part of the model, like the Products and SubProducts lists.
Implications:
MVC Structure: This is an MVC controller, meaning it's designed to interact with views. It retrieves data, populates models, and returns views.
Data Construction: The DataTable construction in the Index action suggests that the system might be using a custom view or grid component to display data in a tabular format.
Data Retrieval and Manipulation: The controller is focused heavily on data operations, especially related to orders and product configurations.
Error Handling: There's a consistent approach to error handling, ensuring a smooth user experience by displaying meaningful error messages.
In summary, the OrderController class provides endpoints for operations related to orders, with a particular focus on displaying and editing them.
