public async Task RemoveSale(SaleDTO sale)
{
var targetSale = Mapper.Map <SaleDTO, Sale>(sale);
salesRepository.Delete(0);
await salesRepository.Save();
}
public async Task Handler_GivenValidData_ShouldUpdateSale()
{
// Arrange
var sale = new SaleDTO
{
Id = 2,
Date = new DateTime(2019, 01, 01),
Amount = 600,
};
var command = new UpdateSaleCommand {
Model = sale
};
// Act
var handler = new UpdateSaleCommand.UpdateSaleCommandHandler(Context);
await handler.Handle(command, CancellationToken.None);
var entity = Context.Sales.Find(sale.Id);
// Assert
entity.ShouldNotBeNull();
entity.Date.ShouldBe(command.Model.Date);
entity.Amount.ShouldBe(command.Model.Amount);
}
public async Task UpdateSale(SaleDTO sale)
{
var targetSale = mapper.Map <SaleDTO, Sale>(sale);
salesRepository.Edit(targetSale);
await salesRepository.Save();
}
public void UpdateProductStocks(SaleDTO sale, int userId)
{
var errorMessage = string.Empty;
var workplaceId = new UserDalFacade().GetAccountUser(userId).WorkPlace.Id.Value;
var productStock =
new ProductStockDalFacade().GetProductStockByPlaceAndProduct(workplaceId, sale.ProductId);
if (sale.Quantity > productStock.Quantity)
{
errorMessage +=
$"Not Enough Product ({productStock.ProductId}-{productStock.ProductName}) in ProductStock to complete transaction.";
}
if (!string.IsNullOrEmpty(errorMessage))
{
errorMessage += Environment.NewLine;
}
if (!string.IsNullOrEmpty(errorMessage))
{
throw new ArgumentOutOfRangeException(errorMessage);
}
var productInStockMinus =
new ProductStockDalFacade().GetProductStockByPlaceAndProduct(workplaceId, sale.ProductId);
productInStockMinus.Quantity -= sale.Quantity;
new ProductStockDalFacade().Update(productInStockMinus);
}
private async Task FindOutIds(SaleDTO sale)
{
if (await Clients.DoesClientExistAsync(sale.Clients).ConfigureAwait(false))
{
sale.Clients.ID = await Clients.GetIdAsync(sale.Clients.Name, sale.Clients.Surname)
.ConfigureAwait(false);
}
else
{
ThrowArgumentException("There is no such Client. Register it!");
}
if (await Managers.DoesManagerExistAsync(sale.Managers))
{
sale.Managers.ID = await Managers.GetIdAsync(sale.Managers.Surname).ConfigureAwait(false);
}
else
{
ThrowArgumentException("There is no such Manager. Register it!");
}
if (await Products.DoesProductExistAsync(sale.Products))
{
sale.Products.ID = await Products.GetIdAsync(sale.Products.Name).ConfigureAwait(false);
}
else
{
ThrowArgumentException("There is no such Product. Register it!");
}
}
public bool SaveUser(SaleDTO data)
{
try
{
Sales sale = new Sales
{
ClientId = data.ClientId,
UserId = data.UserId,
Code = data.Code,
Iva = data.Iva,
NetoWorth = data.NetoWorth,
Total = data.Total,
PaymentMethodId = data.PaymentMethodId,
CreationDate = DateTime.Now
};
context.Sales.Add(sale);
context.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
return(true);
}
public async Task <IActionResult> RegisterNewSale([FromBody] SaleDTO sale)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var createSaleCommand = new CreateSaleCommand {
Model = sale
};
int id;
try
{
id = await _mediator.Send(createSaleCommand);
}
catch
{
_logger.LogInformation($"{sale.Id} {SalesConstants.REGISTER_SALE_CONFLICT}");
return(Conflict());
}
sale.Id = id;
_logger.LogInformation($"{sale.Id} {SalesConstants.REGISTER_SALE_SUCCESS}");
return(CreatedAtAction(nameof(RegisterNewSale), sale));
}
public bool CreateSale(SaleViewModel saleModel)
{
if (saleModel == null)
{
return(false);
}
SaleDTO sale = Mapper.Map <SaleDTO>(saleModel);
SaleDTO added = _unitOfWork.Sales.Add(sale);
if (added != null)
{
try
{
_unitOfWork.SaveChanges();
var saved = _unitOfWork.Sales.Get(s => s.Customer.Equals(added.Customer) &&
s.Product.Equals(added.Product) && s.Manager.Equals(added.Manager) &&
s.Total.Equals(added.Total) && s.SaleDate.Equals(added.SaleDate)).FirstOrDefault();
if (saved != null)
{
saleModel.Id = saved.Id;
}
return(true);
}
catch (Exception e)
{
}
}
return(false);
}
public SaleDTO ConvertToDTO(Sale sale, Boolean finalised, SalePositionLead emp, CustomerDTO cus = null)
{
if (cus == null)
{
var leadSpec = new Specification <SaleLead>(l => l.SaleId == sale.Id);
var cusId = _repoSaleLead.Find(leadSpec);
if (cusId != null)
{
var cusSpec = new Specification <Customer>(c => c.Id == cusId.CustomerId);
var cusName = _repoCustomer.Find(cusSpec).Name;
var record = new SaleDTO {
SaleId = sale.Id, Date = sale.Date, OrderNumber = sale.OrderNumber, CustomerId = cusId.CustomerId, CustomerName = cusName, EmployeeId = emp.EmployeeInSalePosition.Employee.Id, EmployeeName = emp.EmployeeInSalePosition.Employee.Lastname + ", " + emp.EmployeeInSalePosition.Employee.Firstname, Finalised = finalised
};
return(record);
}
else
{
return(new SaleDTO {
SaleId = sale.Id, Date = sale.Date, OrderNumber = sale.OrderNumber, EmployeeId = emp.EmployeeInSalePosition.Employee.Id, EmployeeName = emp.EmployeeInSalePosition.Employee.Lastname + ", " + emp.EmployeeInSalePosition.Employee.Firstname, Finalised = emp.FinalisedSale
});
}
}
else
{
return(new SaleDTO {
SaleId = sale.Id, Date = sale.Date, OrderNumber = sale.OrderNumber, CustomerId = cus.CustomerId, CustomerName = cus.CustomerName, EmployeeId = emp.EmployeeInSalePosition.Employee.Id, EmployeeName = emp.EmployeeInSalePosition.Employee.Lastname + ", " + emp.EmployeeInSalePosition.Employee.Firstname, Finalised = emp.FinalisedSale
});
}
}
public async Task <IActionResult> UpdateSale([FromBody] SaleDTO sale)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (sale.Id <= 0)
{
return(BadRequest(sale.Id));
}
var updateSaleCommand = new UpdateSaleCommand {
Model = sale
};
try
{
await _mediator.Send(updateSaleCommand);
}
catch (Exception)
{
_logger.LogWarning($"{sale.Id} {SalesConstants.UPDATE_SALE_CONFLICT}");
return(Conflict());
}
_logger.LogInformation($"{sale.Id} {SalesConstants.UPDATE_SALE_SUCCESS}");
return(Ok(sale));
}
public IHttpActionResult _UpdateSale([FromBody] SaleDTO sale, string field)
{
try
{
var sale_to_update = db.Sales.SingleOrDefault(a => a.PNR == sale.PNR && a.product_fk == sale.product_fk && a.canceled == false);
sale_to_update.date_update = DateTime.Now;
switch (field)
{
case "price":
sale_to_update.remained_pay = sale.remained_pay;
break;
case "persons":
sale_to_update.persons = sale.persons;
break;
case "comments":
sale_to_update.comments = sale.comments;
break;
default:
break;
}
db.SaveChanges();
return(Ok(sale_to_update));
}
catch (Exception ex)
{
Exception rootEx = ex.GetBaseException();
return(Content(HttpStatusCode.BadRequest, rootEx.Message));
}
}
public bool EditSale(int Id, SaleDTO saleEdited)
{
Sale sale = _db.Sales.FindById(Id);
if (sale != null)
{
sale.Date = saleEdited.Date;
if (saleEdited.Client != null)
{
sale.Client = saleEdited.Client;
}
if (saleEdited.Product != null)
{
sale.Product = saleEdited.Product;
}
if (saleEdited.Price != 0)
{
sale.Price = saleEdited.Price;
}
if (saleEdited.ManagerId != 0)
{
sale.Manager = _db.Managers.FindById(saleEdited.ManagerId);
}
_db.Sales.Update(sale);
_db.Save();
return(true);
}
else
{
return(false);
}
}
public async Task Handler_ShouldAddSale()
{
// Arrange
var sale = new SaleDTO
{
Id = 5,
Date = new DateTime(2020, 03, 01),
Amount = 1000,
};
var command = new CreateSaleCommand {
Model = sale
};
// Act
var handler = new CreateSaleCommand.CreateSaleCommandHandler(Context, Mapper);
await handler.Handle(command, CancellationToken.None);
var entity = Context.Sales.Find(sale.Id);
// Assert
entity.ShouldNotBeNull();
entity.Id.ShouldBe(command.Model.Id);
entity.Date.ShouldBe(command.Model.Date);
entity.Amount.ShouldBe(command.Model.Amount);
}
public async Task <IActionResult> Insert(SaleInsertViewModel viewmodel)
{
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <SaleInsertViewModel, SaleDTO>();
});
IMapper mapper = configuration.CreateMapper();
// new SERService().GetSERByID(4);
//Transforma o ClienteInsertViewModel em um ClienteDTO
SaleDTO dto = mapper.Map <SaleDTO>(viewmodel);
SaleService svc = new SaleService();
try
{
await svc.Insert(dto);
return(RedirectToAction("Index", "Category"));
}
catch (Exception ex)
{
ViewBag.Erros = ex.Message;
}
return(View());
}
public void Add(SaleDTO saleDto)
{
var createdSale = _mapper.Map <SaleDTO, Sale>(saleDto);
_unitOfWork.SaleRepository.Create(createdSale);
_unitOfWork.Save();
}
public async Task <Response> Insert(SaleDTO sale)
{
Response response = new Response();
if (sale.ItemsSales.Count <= 0)
{
response.Errors.Add("Não há nenhum produto na venda");
}
if (response.Errors.Count != 0)
{
response.Success = false;
return(response);
}
sale.CalculatePrice();
try
{
await _saleRepository.Insert(sale);
response.Success = true;
return(response);
}
catch (Exception ex)
{
response.Errors.Add("Erro no banco contate o adm");
response.Success = false;
File.WriteAllText("Log.txt", ex.Message);
return(response);
}
}
private async Task FindOutIds(SaleDTO sale)
{
if (await Clients.DoesClientExistAsync(sale.Clients).ConfigureAwait(false))
{
sale.Clients.ID = await Clients.GetIdAsync(sale.Clients.Name, sale.Clients.Surname)
.ConfigureAwait(false);
}
else
{
ThrowArgumentException("Client not found");
}
if (await Managers.DoesManagerExistAsync(sale.Managers))
{
sale.Managers.ID = await Managers.GetIdAsync(sale.Managers.Surname).ConfigureAwait(false);
}
else
{
ThrowArgumentException("Mfnfger not found");
}
if (await Products.DoesProductExistAsync(sale.Products))
{
sale.Products.ID = await Products.GetIdAsync(sale.Products.Name).ConfigureAwait(false);
}
else
{
ThrowArgumentException("Product not found");
}
}
public async Task Handle_GivenValidId_ReturnsSaleDTO()
{
// Arrange
var sale = new SaleDTO
{
Id = 2,
Date = new DateTime(2020, 01, 01),
Amount = 1200,
};
var query = new GetSaleQuery {
Id = 2
};
// Act
var handler = new GetSaleQuery.GetSaleQueryHandler(Context, Mapper);
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.ShouldBeOfType <SaleDTO>();
result.ShouldNotBeNull();
result.Id.ShouldBe(sale.Id);
result.Date.ShouldBe(sale.Date);
result.Amount.ShouldBe(sale.Amount);
}
public async Task <IHttpActionResult> Remove(SaleModel sale)
{
SaleDTO targetSale = mapper.Map <SaleModel, SaleDTO>(sale);
await saleService.RemoveSale(targetSale);
return(Ok(new ResponseSheme(null, "Ok", 200)));
}
public TransactionStatusModel AddSale(SaleDTO sale)
{
TransactionStatusModel transStatus = new TransactionStatusModel();
using (SqlConnection con = new SqlConnection(cs))
{
try
{
SqlCommand cmd = new SqlCommand("AddSale", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(new SqlParameter("@transactionId", sale.TransactionId));
cmd.Parameters.Add(new SqlParameter("@productId", sale.ProductDto.ProductId));
cmd.Parameters.Add(new SqlParameter("@totalPrice", sale.TotalPrice));
con.Open();
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
transStatus.ReturnMessage.Add("Add Sale failed");
transStatus.ReturnStatus = false;
return(transStatus);
}
}
transStatus.ReturnMessage.Add("Sale successfully added");
transStatus.ReturnStatus = true;
return(transStatus);
}
public void Update(SaleDTO sale)
{
var item = _mapper.Map <SaleDTO, Domain.Entities.Sale>(sale);
_repository.Update(item);
_unitOfWork.SaveChanges();
}
public void UpdateSale(SaleDTO sale)
{
var saleEF = saleRepository.GetBy(sale.IDKM);
sale.MappingSale(saleEF);
saleRepository.Update(saleEF);
}
public void UpdateSale_WithValidModel_Returns_OkResult()
{
// Arrange
var mediatorMock = new Mock <IMediator>();
mediatorMock.Setup(mediator => mediator
.Send(It.IsAny <UpdateSaleCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(It.IsAny <Unit>()));
var loggerMock = new Mock <ILogger <SalesController> >();
var salesServiceMock = new Mock <ISaleStatisticService>();
var controller = new SalesController(loggerMock.Object, mediatorMock.Object, salesServiceMock.Object);
var saleDTO = new SaleDTO {
Id = 1
};
// Act
var result = controller.UpdateSale(saleDTO).GetAwaiter().GetResult();
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.IsAssignableFrom <SaleDTO>(okResult.Value);
}
public Domain.Entities.Sale Add(SaleDTO sale)
{
var item = _mapper.Map <SaleDTO, Domain.Entities.Sale>(sale);
_repository.Insert(item);
_unitOfWork.SaveChanges();
return(item);
}
private sale getMapperBySale(SaleDTO data)
{
return(new sale
{
Id = data.id,
Code = data.saleCode
});
}
public void AddSale(SaleDTO sale, IMapper mapper)
{
if (sale != null)
{
_db.Sales.Create(mapper.Map <SaleDTO, Sale>(sale));
_db.Save();
}
}
public Task ActivateAsync(object parameter)
{
_currentSale = (SaleDTO)parameter;
UpdateDataGrid();
return(Task.CompletedTask);
}
public SaleViewVM(SaleDTO model)
{
this.Id = model.Id;
this.ProductName = model.ProductName;
this.Quantity = model.Quantity;
this.Price = model.Price;
this.Total = model.Total;
this.date = model.date;
}
/// <summary>
/// Method calculates sale total and tax.
/// </summary>
/// <param name="sale">Method takes on SaleDTO as an argument.</param>
/// <returns></returns>
public SaleDTO FinalizeSale(SaleDTO sale)
{
var saleTotal = sale.SaleItems.Aggregate(0m, (current, item) => current + item.SellingPrice);
saleTotal = saleTotal + saleTotal * .06m;
sale.DateOfSale = DateTime.Now;
sale.Total = saleTotal;
return(sale);
}
private BundleModel setBundleData(ShippingDTO shippingResult, SaleDTO saleResult, ProductDTO productResult)
{
return(new BundleModel
{
Status = shippingResult.Status,
Sale = getMapperBySale(saleResult),
Product = getMapperByProduct(productResult)
});
}
