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")); }