public void UpdateOrder(ImportingOrderDto order)
{
var oldOrder = importingOrderRepository.GetBy(order.Id);
oldOrder.ImportingTransactions = importingTransactionRepository.GetByImportingId(order.Id).ToList();
/*Remove old quantity*/
List <Product> productList = new List <Product>();
foreach (var transaction in oldOrder.ImportingTransactions)
{
var product = productRepository.GetBy(transaction.ProductId);
product.Quantity -= transaction.Quantity;
productList.Add(product);
}
productRepository.UpdateQuantity(productList);
/*Remove old transaction*/
importingTransactionRepository.RemoveRange(oldOrder.ImportingTransactions);
/*Add new quantity*/
List <Product> newProductList = new List <Product>();
foreach (var transaction in order.ImportingTransactions)
{
transaction.ImportingOrderId = order.Id;
var product = productRepository.GetBy(transaction.ProductId);
product.Quantity += transaction.Quantity;
newProductList.Add(product);
}
productRepository.UpdateQuantity(newProductList);
/*Add new transaction*/
importingOrderRepository.Update(order.MappingImportingOrder());
}
public IActionResult Edit(ImportingOrderDto order)
{
if (ModelState.IsValid)
{
try
{
importingOrderService.UpdateOrder(order);
}
catch (DbUpdateConcurrencyException)
{
if (!importingOrderService.OrderExists(order.Id))
{
return(NotFound());
}
else
{
throw;
}
}
var orders = importingOrderService.GetAll();
return(Json(new { isValid = true, html = Helper.RenderRazorViewToString(this, "_ViewAll", orders.ToList()) }));
}
ViewBag.Vendor = new SelectList(vendorService.GetAll(), "Id", "Name");
ViewBag.Employees = new SelectList(employeeService.GetAll(), "Id", "Fullname");
return(Json(new { isValid = false, html = Helper.RenderRazorViewToString(this, "Edit", order) }));
}
public ImportingOrderDto CreateImportingOrder(ImportingOrderDto orderDto)
{
var order = _mapper.Map <ImportingOrder>(orderDto);
int res = _orderRepo.Create(order);
if (res <= 0)
{
return(null);
}
return(orderDto);
}
public ActionFeedback <IEnumerable <ImportingOrderDto> > Parse(Stream fileStream)
{
try
{
var result = new List <ImportingOrderDto>();
using (var reader = ExcelReaderFactory.CreateReader(fileStream))
{
var sheets = reader.AsDataSet();
if (!sheets.Tables.Cast <object>().Any())
{
return(ActionFeedback <IEnumerable <ImportingOrderDto> > .Succeed(result));
}
sheets.Tables[0].Rows.RemoveAt(0); // Remove header row
foreach (DataRow row in sheets.Tables[0].Rows)
{
var externalId = row[ColumnIndex.ExternalId].ToString();
if (externalId.HasValue())
{
var dto = new ImportingOrderDto
{
ExternalId = externalId,
OrderedDate = DateTime.Parse(row[ColumnIndex.OrderedDate].ToString()),
Status = OrderStatusMapping[row[ColumnIndex.Status].ToString()],
TrackingNumber = row[ColumnIndex.TrackingNumber].ToString(),
Sku = row[ColumnIndex.Sku].ToString(),
Price = decimal.Parse(row[ColumnIndex.Price].ToString()),
Quantity = int.Parse(row[ColumnIndex.Quantity].ToString()),
ShippingCost = decimal.Parse(row[ColumnIndex.ShippingCost].ToString()),
ShippingAmount = decimal.Parse(row[ColumnIndex.ShippingAmount].ToString()),
OrderTotal = decimal.Parse(row[ColumnIndex.OrderTotal].ToString()),
Username = row[ColumnIndex.Username].ToString(),
Phone = row[ColumnIndex.Phone].ToString(),
ShippingAddress = row[ColumnIndex.ShippingAddress].ToString()
};
result.Add(dto);
}
}
}
return(ActionFeedback <IEnumerable <ImportingOrderDto> > .Succeed(result));
}
catch (Exception exception)
{
_telemetry.TrackException(exception);
return(ActionFeedback <IEnumerable <ImportingOrderDto> > .Fail(exception.Message));
}
}
//Map from Dto to Entity
public static ImportingOrder MappingImportingOrder(this ImportingOrderDto importingOrderDto)
{
return(new ImportingOrder
{
Id = importingOrderDto.Id,
VendorId = importingOrderDto.VendorId,
EmployeeId = importingOrderDto.EmployeeId,
NameCode = importingOrderDto.NameCode,
TotalPrice = importingOrderDto.TotalPrice,
CreatedDate = (System.DateTime)importingOrderDto.CreatedDate,
Status = importingOrderDto.Status,
ImportingTransactions = importingOrderDto.ImportingTransactions.MappingTransactions().ToList(),
});
}
public IActionResult Add(ImportingOrderDto order)
{
if (ModelState.IsValid)
{
order.Vendor = vendorService.GetVendor(order.VendorId);
order.Employee = employeeService.GetEmployee(order.EmployeeId);
importingOrderService.CreateOrder(order);
}
ViewBag.Vendor = new SelectList(vendorService.GetAll(), "Id", "Name");
ViewBag.Employees = new SelectList(employeeService.GetAll(), "Id", "Fullname");
return(Json(new { isValid = false, html = Helper.RenderRazorViewToString(this, "Add", order) }));
}
public void CreateOrder(ImportingOrderDto orderDto)
{
orderDto.CreatedDate = System.DateTime.UtcNow;
List <Product> productList = new List <Product>();
foreach (var transaction in orderDto.ImportingTransactions)
{
var product = productRepository.GetBy(transaction.ProductId);
product.Quantity += transaction.Quantity;
productList.Add(product);
}
importingOrderRepository.Add(orderDto.MappingImportingOrder());
productRepository.UpdateQuantity(productList);
}
private async Task <OrderItemVm> GetOrderItemAsync(ImportingOrderDto orderDto)
{
var productId = await _productService.GetProductIdBySkuAsync(orderDto.Sku);
if (productId <= 0)
{
return(null);
}
return(new OrderItemVm
{
ProductId = productId,
Quantity = orderDto.Quantity,
ProductPrice = orderDto.Price
});
}
public ActionResult <ImportingOrderDto> UpdateImportingOrder([FromBody] ImportingOrderDto order)
{
var orderDto = _orderService.UpdateImportingOrder(order);
if (orderDto == null)
{
List <string> errorMessage = new List <string>();
errorMessage.Add("Đã phát sinh lỗi, vui lòng thử lại");
return(BadRequest(new ResponseDto(errorMessage, 500, orderDto)));
}
List <string> successMessage = new List <string>();
successMessage.Add("Sửa thông tin thành công");
var responseDto = new ResponseDto(successMessage, 200, orderDto);
return(Ok(responseDto));
}
private async Task <long> GetCustomerIdAsync(ImportingOrderDto orderDto)
{
var customerId = await _customerService.GetCustomerIdByPhoneAsync(orderDto.Phone);
if (customerId <= 0)
{
var dto = new CreateCustomerDto
{
FullName = orderDto.Username,
PhoneNumber = orderDto.Phone,
Address = orderDto.ShippingAddress,
Email = $"{orderDto.Phone}@mail.com",
Password = orderDto.Phone
};
customerId = await _customerService.CreateCustomerAsync(dto);
}
return(customerId);
}
public ActionResult <ImportingOrderDto> CreateImportingOrder([FromBody] ImportingOrderDto order)
{
order.SupplierId = order.Supplier.Id;
order.Supplier = null;
order.EmployeeId = order.Employee.Id;
order.Employee = null;
var orderDto = _orderService.CreateImportingOrder(order);
if (orderDto == null)
{
List <string> errorMessage = new List <string>();
errorMessage.Add("Đã phát sinh lỗi, vui lòng thử lại");
return(BadRequest(new ResponseDto(errorMessage, 500, orderDto)));
}
List <string> successMessage = new List <string>();
successMessage.Add("Thêm thông tin thành công");
var responseDto = new ResponseDto(successMessage, 200, orderDto);
return(Ok(responseDto));
}
public void DeleteOrder(ImportingOrderDto order)
{
throw new System.NotImplementedException();
}
