public void Update()
{
// Arrange
ISaleWorker SaleWorker = new SaleWorker();
Guid salesId = Guid.NewGuid();
SaleDto saleDto = new SaleDto()
{
CustomerID = 1,
ProductID = 2,
Quantity = 3,
SaleDate = DateTime.Now,
SalesGuid = salesId
};
// ACT
SaleWorker.Create(saleDto);
saleDto.Quantity = 7;
var salesById = SaleWorker.Search(salesId);
saleDto.ID = salesById.ID;
SaleWorker.Update(saleDto);
// Assert
var sale = SaleWorker.Search(salesId);
Assert.AreEqual(sale.Quantity, saleDto.Quantity, "No se actualizo correctamente");
}
public SaleDto ToDto(Sale sale)
{
var result = new SaleDto();
result.Change = sale.Change;
result.Id = sale.Id;
result.PaidAmount = sale.PaidAmount;
result.Total = sale.Total;
if (sale.ChangeDetails != null)
{
result.ChangeDetails = new List <ChangeDetailDto>();
for (int i = 0; i < sale.ChangeDetails.Count; i++)
{
var detail = new ChangeDetailDto();
detail.DetailTotal = sale.ChangeDetails.ElementAt(i).DetailTotal;
detail.IsCoin = sale.ChangeDetails.ElementAt(i).IsCoin;
detail.Qty = sale.ChangeDetails.ElementAt(i).Qty;
detail.Value = sale.ChangeDetails.ElementAt(i).Value;
result.ChangeDetails.Add(detail);
}
}
return(result);
}
public async Task <IActionResult> UpdateSale([FromRoute] int id, [FromBody] SaleDto entityDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != entityDto.Id)
{
return(BadRequest());
}
var entity = await _repository.GetByIdAsync(entityDto.Id);
if (entity == null)
{
return(NotFound("Sale does not exist"));
}
_mapper.Map(entityDto, entity);
try
{
_repository.Update(entity);
await _unitOfWork.SaveAsync();
}
catch (Exception)
{
throw new Exception("An unexpected error occured. Could not update.");
}
return(Ok(_mapper.Map <SaleDto>(entity)));
}
public IHttpActionResult Create([FromBody] SaleDto saleDto)
{
if (saleDto == null)
{
return(BadRequest(ModelState));
}
var customer = customerWorker.Search(saleDto.CustomerID);
if (!Convert.ToBoolean(customer.Enable))
{
return(BadRequest($"El cliente {saleDto.CustomerID} se encuentra desactivado. No se puede realizar la venta."));
}
var product = productWorker.Search(saleDto.ProductID);
if (!Convert.ToBoolean(product.Enable))
{
return(BadRequest($"El producto {saleDto.ProductID} se encuentra desactivado. No se puede realizar la venta."));
}
saleDto.SalesGuid = Guid.NewGuid();
if (!saleWorker.Create(saleDto))
{
ModelState.AddModelError("", "Ocurrió un error al crear la venta ");
return(StatusCode(HttpStatusCode.InternalServerError));
}
else
{
return(Ok("venta creada con éxito"));
}
}
public async Task <IActionResult> AddAsync(
[FromBody] SaleDto dto)
{
try
{
// Parse DTO
if (string.IsNullOrWhiteSpace(dto?.Date))
{
throw new SaleExceptions.DateRequired();
}
if (!DateTime.TryParseExact(dto?.Date, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
{
throw new SaleExceptions.DateInvalid();
}
// Add sale
SaleDetails sale = await this.SaleService.AddSaleAsync(
dto?.TransactionId,
date,
dto?.Amount ?? throw new SaleExceptions.AmountRequired(),
dto?.Notes).ConfigureAwait(false);
// Map to DTO model
string actionName = nameof(this.GetAsync);
if (actionName.EndsWith("Async"))
{
actionName = actionName[0..^ 5];
public async Task <ServiceResponse <int> > CreateAsync(SaleDto sale, int userId)
{
if (sale == null)
{
throw new ArgumentNullException(nameof(sale));
}
var entity = sale.ToEntity();
entity.UpdateCreatedFields(userId).UpdateModifiedFields(userId);
var location = await UnitOfWork.Get <Location>().GetAsync(entity.LocationID);
location.UpdateModifiedFields(userId);
if (entity.ClientID.HasValue)
{
var client = await UnitOfWork.Get <Client>().GetAsync(entity.ClientID.Value);
client.UpdateModifiedFields(userId);
}
entity.Recommendations?.UpdateCreatedFields(userId).UpdateModifiedFields(userId);
entity.Attachments?.UpdateCreatedFields(userId).UpdateModifiedFields(userId);
var added = UnitOfWork.Get <Sale>().Add(entity);
await UnitOfWork.SaveAsync();
return(new SuccessResponse <int>(added.ID));
}
public async Task UpdateAsync(int saleId, SaleDto sale, CancellationToken cancellationToken)
{
var entity = await _dbContext.Sales.FindAsync(saleId);
if (entity == null)
{
throw new NotFoundException(nameof(Sale), saleId);
}
var newEntity = MapFromDto(sale);
entity.OrderId = newEntity.OrderId;
entity.SalesChannel = newEntity.SalesChannel;
entity.ShippedAt = newEntity.ShippedAt;
entity.UnitsSold = newEntity.UnitsSold;
entity.UnitPrice = newEntity.UnitPrice;
entity.UnitCost = newEntity.UnitCost;
entity.TotalRevenue = newEntity.TotalRevenue;
entity.TotalCost = newEntity.TotalCost;
entity.TotalProfit = newEntity.TotalProfit;
entity.Order = newEntity.Order;
entity.Item = newEntity.Item;
entity.Country = newEntity.Country;
await _dbContext.SaveChangesAsync(cancellationToken);
}
private SaleDataDto GetSaleData(int additionalSum = 0)
{
SaleDataDto saleData = new SaleDataDto()
{
SourceFileName = "AlNaz_18121980.json",
FileDate = DateTime.UtcNow
};
List <SaleDto> saleDtos = new List <SaleDto>();
for (int i = 0; i < 10; i++)
{
SaleDto saleDto = new SaleDto()
{
SaleDate = new DateTime(2018, i + 1, i + 1),
CustomerName = $"Customer #{i + 1}",
ProductName = $"Product #{i + 1}",
TotalSum = (i + 10) * 10
};
SaleDto saleDto2 = new SaleDto()
{
SaleDate = new DateTime(2018, i + 1, i + 1),
CustomerName = $"Customer #{i + 1}",
ProductName = $"Product #{i + 1}",
TotalSum = (i + 10) * 10 + additionalSum
};
saleDtos.Add(saleDto);
saleDtos.Add(saleDto2);
}
saleData.Sales = saleDtos;
return(saleData);
}
public string ExportSalesWithDiscount()
{
var sales = context.Sales
.Include(s => s.Customer)
.Include(s => s.Car)
.ThenInclude(c => c.PartCars)
.ThenInclude(pc => pc.Part)
.ToArray();
var saleDtos = new SaleDto[sales.Length];
for (int i = 0; i < sales.Length; i++)
{
var sale = sales[i];
var saleDto = Mapper.Map <SaleDto>(sale);
saleDto.Price = sale.Car.PartCars.Sum(pc => pc.Part.Price);
saleDto.PriceWithDiscount = sale.Car.PartCars.Sum(pc => pc.Part.Price)
* (1 - sale.Discount -
(sale.Customer.IsYoungDriver ? 0.05M : 0M));
saleDtos[i] = saleDto;
}
var sb = new StringBuilder();
var serializer = new XmlSerializer(saleDtos.GetType(), new XmlRootAttribute("sales"));
serializer.Serialize(new StringWriter(sb), saleDtos, new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty }));
return(sb.ToString());
}
/// <summary>
/// Creates a sale record
/// </summary>
/// <param name="saleDto">saleDto</param>
public void Create(SaleDto saleDto)
{
lock (lockObject) {
Sale sale = new Sale()
{
InvoiceNumber = Guid.NewGuid(),
SaleDate = DateTime.Now,
Discount = saleDto.Discount,
VATAmount = saleDto.VATAmount,
TotalAmount = saleDto.TotalAmount
};
var user = _unitOfWork.UserRepository.GetById(saleDto.UserId) ?? throw new CustomException(HttpStatusCode.NotFound, Constants.ErrorUserNotFound);
sale.UserId = user.Id;
foreach (var saleItem in saleDto.SaleItems)
{
var product = _unitOfWork.ProductRepository.GetById(saleItem.ProductId) ?? throw new CustomException(HttpStatusCode.NotFound, Constants.ErrorProductNotFound);
if (product.AvailableQuantity < saleItem.Quantity)
{
throw new CustomException(HttpStatusCode.NotAcceptable, Constants.InvalidProductQuantity);
}
product.AvailableQuantity -= saleItem.Quantity;
SaleProduct saleProduct = new SaleProduct
{
InvoiceNumber = sale.InvoiceNumber.ToString(),
ProductId = saleItem.ProductId,
Quantity = saleItem.Quantity
};
_unitOfWork.SaleProductRepository.Insert(saleProduct);
}
_unitOfWork.SaleRepository.Insert(sale);
_unitOfWork.Commit();
}
}
public async Task <IActionResult> Create(SaleDto saleDto)
{
if (ModelState.IsValid)
{
try
{
var sale = await saleService.ConvertFromDtoAsync(saleDto);
var created = await saleService.CreateAsync(sale);
foreach (var saleProduct in sale.SaleProduct)
{
await productService.DecreaseStock(saleProduct.ProductId, saleProduct.Quantity);
}
var Dto = saleService.ConvertToDto(created);
return(CreatedAtAction(nameof(GetSaleById), new { id = Dto.SaleId }, Dto));
}
catch (Exception)
{
return(BadRequest());
}
}
return(BadRequest());
}
public void AddSalesToStoreAndDecrementStockProducts(SaleDto saleDto)
{
var newSale = new Sale()
{
SellingDate = saleDto.SellingDate,
StoreId = saleDto.StoreId
};
_shoesDataEntities.Sales.Add(newSale);
foreach (var saleProductDto in saleDto.SalesProducts)
{
var currentProduct = _productServices.FindProduct(
saleProductDto.ModelId, saleProductDto.ColorId, saleProductDto.Size);
var newSaleProduct = new SaleProduct
{
ProductId = currentProduct.Id,
SaleId = newSale.Id,
Quantity = saleProductDto.Quantity,
SellingPrice = saleProductDto.Price
};
_shoesDataEntities.SaleProducts.Add(newSaleProduct);
var lastStockRoom = _storeStockRoomDataServices.GetLastStoreStockRoomByProductId(saleDto.StoreId.Value, currentProduct.Id);
var newStoreStockRoom = new StoreStockRoom()
{
ProductId = currentProduct.Id,
StockValue = lastStockRoom.StockValue - saleProductDto.Quantity,
EntryValue = -saleProductDto.Quantity,
EntryDate = saleDto.SellingDate,
StoreId = saleDto.StoreId.Value,
OperationType = OperationType.OUT.ToString()
};
_shoesDataEntities.StoreStockRooms.Add(newStoreStockRoom);
SaveChanges();
}
}
public static SaleDto ToDto(this Sale model)
{
var dto = new SaleDto
{
ID = model.ID,
ClientID = model.ClientID,
Client = model.Client?.ToDto(),
LocationID = model.LocationID,
Location = model.Location?.ToDto(),
UserID = model.UserID,
User = model.User?.ToDto(),
IsSubmitted = model.IsSubmitted,
Date = model.Date,
TotalPrice = model.TotalPrice ?? model.Goods?.Sum(g => g.Price),
DollarRate = model.DollarRate,
IsCachless = model.IsCachless,
IsWriteOff = model.IsWriteOff,
EuroRate = model.EuroRate,
Goods = model.Goods?.Where(di => !di.IsDeleted).Select(i => i.ToDto())
};
dto.MapDetails(model);
dto.CanBeDeleted = !(model.IsSubmitted || model.IsDeleted);
return(dto);
}
public void ChangeState()
{
// Arrange
ISaleWorker SaleWorker = new SaleWorker();
Guid salesId = Guid.NewGuid();
SaleDto saleDto = new SaleDto()
{
CustomerID = 2,
ProductID = 1,
Quantity = 1,
SaleDate = DateTime.Now,
SalesGuid = salesId
};
// ACT
SaleWorker.Create(saleDto);
var salesById = SaleWorker.Search(salesId);
saleDto.ID = salesById.ID;
saleDto.State = Core.Enums.StateTypes.States.Accept.ToString();
SaleWorker.ChangeState(saleDto.ID, Core.Enums.StateTypes.States.Accept);
// Assert
var sale = SaleWorker.Search(salesId);
Assert.AreEqual(sale.State, saleDto.State, "No se cambio el estado correctamente");
}
public async Task <Sale> ConvertFromDtoAsync(SaleDto saleDto)
{
var client = await context.Client.Where(x => x.NameClient == saleDto.ClientName).FirstOrDefaultAsync();
return(new Sale {
SaleDate = saleDto.SaleDate, SaleProduct = saleDto.SaleProduct, Client = client, ClientId = client.ClientId, TotalValue = saleDto.TotalValue
});
}
public void ConvertToDto_SaleNotNull_ReturnSameStatus()
{
Sale sale = MockSale();
SaleDto saleDto = sale.ConvertToDto();
Assert.Equal(sale.Status, saleDto.Status);
}
public void ConvertToDto_SaleNotNull_ReturnSameProducts()
{
Sale sale = MockSale();
SaleDto saleDto = sale.ConvertToDto();
Assert.Equal(sale.Products, saleDto.Products);
}
public void ConvertToDto_SaleNotNull_ReturnSameCouponCode()
{
Sale sale = MockSale();
SaleDto saleDto = sale.ConvertToDto();
Assert.Equal(sale.CouponCode, saleDto.CouponCode);
}
public void ConvertToDto_SaleNotNull_ReturnSameOrderId()
{
Sale sale = MockSale();
SaleDto saleDto = sale.ConvertToDto();
Assert.Equal(sale.OrderId, saleDto.OrderId);
}
public async Task <string> UpdateAsync(SaleDto entity)
{
string retorno = "";
Sale sale = new Sale()
{
ClientId = entity.ClientId,
FinalValue = entity.FinalValue,
Id = entity.Id,
SaleDate = entity.SaleDate,
Vendor = entity.Vendor
};
retorno = await _repository.UpdateAsync(sale);
if (retorno == "")
{
foreach (ItemSaleDto item in entity.ItemSale)
{
if (item.Action == ActionItem.Insert)
{
retorno = await _itemSaleRepository.AddAsync(new ItemSale()
{
Id = item.Id,
Price = item.Price,
ProductId = item.ProductId,
Quantity = item.Quantity,
SaleId = item.SaleId,
TotalPrice = item.TotalPrice
});
}
else if (item.Action == ActionItem.Alter)
{
retorno = await _itemSaleRepository.UpdateAsync(new ItemSale()
{
Id = item.Id,
Price = item.Price,
ProductId = item.ProductId,
Quantity = item.Quantity,
SaleId = item.SaleId,
TotalPrice = item.TotalPrice
});
}
else if (item.Action == ActionItem.Delete)
{
retorno = await _itemSaleRepository.RemoveAsync(item.Id);
}
if (retorno != "")
{
break;
}
}
}
return(retorno);
}
public async Task <DashboardListDto> GetDashboardList()
{
var dashboardList = new DashboardListDto();
var product = await _productSaleRepository.GetAll()
.Include(i => i.ShopProduct)
.ToListAsync();
var productCost = await _shopProductRepository.GetAll().ToListAsync();
var expense = await _expenseRepository.GetAll().ToListAsync();
var thisWeek = ThisWeek(product, productCost, expense);
var thisMonth = ThisMonth(product, productCost, expense);
var thisYear = ThisYear(product, productCost, expense);
var today = Today(product, productCost, expense);
var yesterday = Yesterday(product, productCost, expense);
var sale = new SaleDto();
sale.Today = today.Sale;
sale.Yesterday = yesterday.Sale;
sale.ThisWeek = thisWeek.Sum(i => i.Sale);
sale.ThisMonth = thisMonth.Sum(i => i.Sale);
sale.ThisYear = thisYear.Sum(i => i.Sale);
var costing = new SaleDto();
costing.Today = today.ProductCost;;
costing.Yesterday = yesterday.ProductCost;
costing.ThisWeek = thisWeek.Sum(i => i.ProductCost);
costing.ThisMonth = thisMonth.Sum(i => i.ProductCost);
costing.ThisYear = thisYear.Sum(i => i.ProductCost);
var expenses = new SaleDto();
expenses.Today = today.Expense;;
expenses.Yesterday = yesterday.Expense;
expenses.ThisWeek = thisWeek.Sum(i => i.Expense);
expenses.ThisMonth = thisMonth.Sum(i => i.Expense);
expenses.ThisYear = thisYear.Sum(i => i.Expense);
var profit = new SaleDto();
profit.Today = today.Profit;;
profit.Yesterday = yesterday.Profit;
profit.ThisWeek = thisWeek.Sum(i => i.Profit);
profit.ThisMonth = thisMonth.Sum(i => i.Profit);
profit.ThisYear = thisYear.Sum(i => i.Profit);
dashboardList.Sale = sale;
dashboardList.Costing = costing;
dashboardList.Expenses = expenses;
dashboardList.Profit = profit;
return(dashboardList);
}
public async Task <int> CreateAsync(SaleDto sale, CancellationToken cancellationToken)
{
var entity = MapFromDto(sale);
_dbContext.Sales.Add(entity);
await _dbContext.SaveChangesAsync(cancellationToken);
return(entity.Id);
}
public async Task <ServiceResponse <SaleDto> > UpdateAsync(SaleDto sale, int userId)
{
if (sale == null)
{
throw new ArgumentNullException(nameof(sale));
}
var existentSale = await UnitOfWork.Get <Sale>().GetAsync(sale.ID);
if (existentSale == null)
{
return(new ServiceResponse <SaleDto>(ServiceResponseStatus.NotFound));
}
var goods = UnitOfWork.Get <Goods>()
.GetAll(g => g.SaleID == sale.ID, g => g.Storages)
.ToList();
existentSale.Goods = goods;
foreach (var good in existentSale.Goods)
{
if (sale.IsSubmitted && !existentSale.IsSubmitted)
{
good.IsSold = true;
good.Storages.OrderBy(st => st.FromDate).Last().ToDate = DateTime.Now;
}
if (sale.IsWriteOff)
{
good.Price = 0.0M;
}
good.UpdateModifiedFields(userId);
UnitOfWork.Get <Goods>().Update(good);
}
var entity = sale.ToEntity();
existentSale.TotalPrice = sale.IsWriteOff ? 0.0M : existentSale.Goods.Sum(g => g.Price);
existentSale.Attachments = GetAttachments(existentSale.ID).ToList();
existentSale.Recommendations = GetRecommendations(existentSale.ID).ToList();
existentSale
.UpdateFields(entity)
.UpdateAttachments(entity, UnitOfWork, userId)
.UpdateRecommendations(entity, UnitOfWork, userId)
.UpdateModifiedFields(userId);
UnitOfWork.Get <Sale>().Update(existentSale);
await UnitOfWork.SaveAsync();
return(new SuccessResponse <SaleDto>());
}
public async Task <ActionResult> UpdateAsync(int id, [FromBody] SaleDto sale)
{
if (id != sale.Id)
{
return(BadRequest());
}
await _salesService.UpdateAsync(id, sale, HttpContext.RequestAborted);
return(NoContent());
}
public IActionResult Create(SaleDto saleDto)
{
try
{
_saleService.Create(saleDto);
return(Ok());
}
catch (CustomException exception)
{
return(StatusCode(exception.ErrorDetails.StatusCode, exception.ErrorDetails));
}
}
public async Task <IActionResult> GetSale(Guid id)
{
Sale saleFromRepo = await _salesRepository.GetSale(id);
if (saleFromRepo == null)
{
return(NotFound());
}
SaleDto sale = Mapper.Map <SaleDto>(saleFromRepo);
return(Ok(sale));
}
public bool AssessBalance(SaleDto sale)
{
var productToQuery = _context.Products.SingleOrDefault(x => x.Id == sale.ProductId);
var studentToQuery = _context.Students.SingleOrDefault(x => x.Id == sale.StudentId);
if (productToQuery == null || studentToQuery == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(studentToQuery.AccountBalance >= productToQuery.Price);
}
public async Task Can_Add_Then_Find_Multiple_Sales_For_The_Previous_Calendar_Month()
{
// ARRANGE
HttpClient client = this.Fixture.HttpClient;
// Prepare data
DateTime endDate = DateTime.UtcNow.Date;
DateTime startDate = endDate.AddMonths(-1);
Random random = new Random();
List <string> transactionIds = new List <string>();
string run = Guid.NewGuid().ToString("N", null).Substring(0, 8);
// ACT
// Create sales
for (DateTime date = startDate; date <= endDate; date = date.AddDays(1))
{
// Create data
SaleDto payload = new SaleDto
{
TransactionId = Guid.NewGuid().ToString("N", null),
Date = date.ToString("yyyy-MM-dd"),
Amount = Math.Round(random.NextDouble() * 100, 2),
Notes = "Integration test data " + run,
};
// Capture generated transaction IDs
transactionIds.Add(payload.TransactionId);
// Create sale
HttpResponseMessage createSaleHttpResponse = await client.PostAsJsonAsync("api/sales", payload).ConfigureAwait(false);
createSaleHttpResponse.EnsureSuccessStatusCode();
}
// Search for sales
string endpoint = string.Format("api/sales?from={0}&to={1}", startDate.ToString("yyyy-MM-dd"), endDate.ToString("yyyy-MM-dd"));
HttpResponseMessage querySalesHttpResponse = await client.GetAsync(endpoint).ConfigureAwait(false);
querySalesHttpResponse.EnsureSuccessStatusCode();
SaleSummaryDto[] salesData = await querySalesHttpResponse.Content.ReadAsAsync <SaleSummaryDto[]>();
// ASSERT
Assert.NotNull(salesData);
foreach (string transactionId in transactionIds)
{
Assert.Contains(transactionId, salesData.Select(x => x.TransactionId));
}
}
public void AddSale(SaleDto saleDto)
{
lock (_objLock)
{
var manager = new DAL.Models.Manager()
{
SecondName = saleDto.Manager
};
var client = new DAL.Models.Client()
{
FullName = saleDto.Client
};
var product = new DAL.Models.Product()
{
Name = saleDto.Product
};
var managerId = _unitOfWork.Managers.GetId(manager);
if (managerId == null)
{
_unitOfWork.Managers.Create(manager);
_unitOfWork.Save();
managerId = _unitOfWork.Managers.GetId(manager);
}
var clientId = _unitOfWork.Clients.GetId(client);
if (clientId == null)
{
_unitOfWork.Clients.Create(client);
_unitOfWork.Save();
clientId = _unitOfWork.Clients.GetId(client);
}
var productId = _unitOfWork.Products.GetId(product);
if (productId == null)
{
_unitOfWork.Products.Create(product);
_unitOfWork.Save();
productId = _unitOfWork.Products.GetId(product);
}
var sale = new DAL.Models.SaleInfo()
{
ClientId = (int)clientId,
ManagerId = (int)managerId,
ProductId = (int)productId,
Date = saleDto.Date,
Amount = saleDto.Amount
};
_unitOfWork.SalesInfo.Create(sale);
_unitOfWork.Save();
}
}
public IHttpActionResult Purchase(Checkout data)
{
//Check student actually exists
var student = _context.Students.SingleOrDefault(x => x.Id == data.StudentId);
if (student == null)
{
return(Content(HttpStatusCode.NotFound, "Student not found"));
}
//Obtain items from student's shopping basket
var basket = _context.BasketItems.Where(x => x.StudentId == data.StudentId);
//Check there are actually items in the basket
if (!basket.Any())
{
return(Content(HttpStatusCode.BadRequest, "There are no items in your basket"));
}
//Check student has enough money to afford all items
var totalCost = basket.Sum(x => x.Product.Price);
if (totalCost > student.AccountBalance)
{
return(Content(HttpStatusCode.BadRequest, "Insufficient funds"));
}
//Process sales for each item
foreach (var item in basket)
{
var sale = new SaleDto
{
StudentId = data.StudentId,
ProductId = item.ProductId,
Date = DateTime.Today
};
InvokeSale(sale);
}
//Remove items from student's basket once transaction has completed
_context.BasketItems.RemoveRange(basket);
_context.SaveChanges();
return(Ok("Purchase completed"));
}
