public int GiveProduct(List <int> productAvailabilityIds, int teamId, int newProductId)
{
using (AppContext db = new AppContext())
{
foreach (int productAvailabilityId in productAvailabilityIds)
{
ProductAvailability productAvailability = db.ProductAvailabilities.Where(pa => pa.Id == productAvailabilityId).First();
db.ProductAvailabilities.Remove(productAvailability);
db.SaveChanges();
}
Product product = db.Products.Where(p => p.Id == newProductId).First();
Department department = (from d in db.Departments
join t in db.Teams on d.Id equals t.Department.Id
where t.Id == teamId
select d).First();
db.ProductAvailabilities.Add(new ProductAvailability {
Product = product, Department = department
});
db.SaveChanges();
Department source = department;
Department destination = department;
DateTime movementDate = DateTime.Now;
Team team = db.Teams.Where(t => t.Id == teamId).First();
Movement movement = new Movement {
Product = product, Source = source, Destination = destination, MovementDate = movementDate, Team = team
};
db.Movements.Add(movement);
db.SaveChanges();
}
return(1);
}
/*Add New Product Detail*/
public ServiceResponse SaveProduct(ProductModel productModel)
{
var product = new Product();
var productAccountPrice = new ProductAccountPrice();
var productAvailability = new ProductAvailability();
var productPricing = new ProductPricing();
Mapper.Map(productModel, product);
Mapper.Map(productModel.ProductAccountPriceModel, product.ProductAccountPrice);
Mapper.Map(productModel.ProductAvailabilityModel, product.ProductAvailability);
Mapper.Map(productModel.ProductPricingModel, product.ProductPricing);
Mapper.Map(productModel.ProductDivisionModel, product.ProductDivision);
Mapper.Map(productModel.ProductCategoryModel, product.ProductCategory);
Mapper.Map(productModel.ProductAttributeModel, product.ProductAttribute);
product.CreatedBy = GetLoginUserId();
product.ProductAccountPrice.ToList().ForEach(m => m.CreatedBy = GetLoginUserId());
product.ProductPricing.ToList().ForEach(m => m.CreatedBy = GetLoginUserId());
_unitOfWork.productRespository.Insert(product);
_unitOfWork.Save();
Mapper.Map(product, productModel);
Mapper.Map(product.ProductClass, productModel.ProductClassModel);
Mapper.Map(product.ProductAccountPrice, productModel.ProductAccountPriceModel);
Mapper.Map(product.ProductAvailability, productModel.ProductAvailabilityModel);
Mapper.Map(product.ProductPricing, productModel.ProductPricingModel);
Mapper.Map(product.ProductDivision, productModel.ProductDivisionModel);
Mapper.Map(product.ProductCategory, productModel.ProductCategoryModel);
Mapper.Map(product.ProductAttribute, productModel.ProductAttributeModel);
return(new ServiceResponse {
Success = true, Message = "Saved", Data = productModel
});
}
public Basket UpdateBasket(AddProductToBasketRequestModel basketItems, ProductAvailability productAvailability, Basket userBasket)
{
var addedBasketLine = userBasket.BasketLines.FirstOrDefault(x => x.ProductId == basketItems.ProductId);
if (addedBasketLine != null)
{
var newQuantity = addedBasketLine.Quantity + basketItems.Quantity;
var availableStockModelForNewQuantity = _stockService.HasAvailableStock(new StockRequestModel()
{
ProductId = basketItems.ProductId, Quantity = newQuantity
});
if (availableStockModelForNewQuantity == null)
{
_logger.LogError("Stock is not sufficient");
throw new ProductIsNotAvailableException("Stock is not sufficient");
}
addedBasketLine.Quantity = newQuantity;
addedBasketLine.GiftNote = basketItems.GiftNote;
}
else
{
userBasket.BasketLines.Add(CreateNewBasketLine(basketItems, productAvailability));
}
return(userBasket);
}
public int TakeProduct(int productAvailabilityId, int teamId)
{
using (AppContext db = new AppContext())
{
Department source = (from pa in db.ProductAvailabilities
join d in db.Departments on pa.Department.Id equals d.Id
where pa.Id == productAvailabilityId
select d).First();
ProductAvailability productAvailability = db.ProductAvailabilities.Where(pa => pa.Id == productAvailabilityId).First();
var department = (from d in db.Departments
join t in db.Teams on d.Id equals t.Department.Id
where t.Id == teamId
select d).First();
productAvailability.Department = department;
db.SaveChanges();
Product product = (from pa in db.ProductAvailabilities
join p in db.Products on pa.Product.Id equals p.Id
where pa.Id == productAvailabilityId
select p).First();
Department destination = department;
DateTime movementDate = DateTime.Now;
Team team = db.Teams.Where(t => t.Id == teamId).First();
Movement movement = new Movement {
Product = product, Source = source, Destination = destination, MovementDate = movementDate, Team = team
};
db.Movements.Add(movement);
db.SaveChanges();
}
return(1);
}
public int DeleteProduct(int productAvailabilityId)
{
using (AppContext db = new AppContext())
{
ProductAvailability productAvailability = db.ProductAvailabilities.Where(pa => pa.Id == productAvailabilityId).First();
db.ProductAvailabilities.Remove(productAvailability);
db.SaveChanges();
}
return(1);
}
public ProductAvailabilityDto MapModelToDto(ProductAvailability model)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <ProductAvailability, ProductAvailabilityDto>();
});
var mapper = config.CreateMapper();
return(mapper.Map <ProductAvailabilityDto>(model));
}
public async Task AddAsync(ProductDetailsDTO product) // Dodaje nowy produkt
{
_logger.LogInformation(1, $"Tworze product o guid {product.Id}");
//Sprawdzam czy ProductDefinition istnieje
//Jak nie istnieje dodaje
var productDefinition = await _productDefinitionRepository.CreateIfNullAsync(product.Name,
product.Description, product.Mark, product.Collection, product.IsAvaible);
//Sprawdzam czy istnieje identyczny produkt
//Jak tak podaj błąd
var Product = await _productRepository.GetProductByDefinitionSizeAndColorAsync(productDefinition.Id,
product.SizeId, product.ColorId);
if (Product != null)
{
_logger.LogError(1, $"Product named: '{product.Name}' and colorId : '{product.ColorId}' and sizeId : '{product.SizeId}' already exist");
throw new Exception($"Product named: '{product.Name}' and colorId : '{product.ColorId}' and sizeId : '{product.SizeId}' already exist");
}
//Sprawdzam czy jest choć jedno zdjęcie
if (product.ProductFotosDTO.Count == 0)
{
_logger.LogError(1, $"Product named: '{product.Name}' doesn't have any picture. Stop process of adding product.");
throw new Exception($"Product named: '{product.Name}' doesn't have any picture");
}
//Dodaje product
var ColorValue = await _colorRepository.GetByIdAsync(product.ColorId);
var SizeValue = await _sizeRepository.GetByIdAsync(product.SizeId);
Product = new Product(product.Id, product.IsAvaible, product.Discount, ColorValue.Name, SizeValue.Name, productDefinition.Id, product.SizeId, product.ColorId, product.CategoryId, product.Price);
Task AddProduct = _productRepository.AddAsync(Product);
await AddProduct;
//Dodaje dotepnosc produktu
Task.WaitAll(AddProduct);
var ProductAvailability = new ProductAvailability(Guid.NewGuid(), product.Quantity, product.Id);
await _productAvailabilityRepository.AddAsync(ProductAvailability);
//Dodaje zdjęcia
int Index = 1;
foreach (var productFoto in product.ProductFotosDTO)
{
var newFoto = new ProductFoto(Guid.NewGuid(), product.Id, productDefinition.Id, productFoto.FotoUrl, productFoto.Description, Index);
Index++;
await _productFotoRepository.AddAsync(newFoto);
}
}
public Basket CreateNewBasket(AddProductToBasketRequestModel basketItems, ProductAvailability productAvailability)
{
List <BasketLine> basketLines = new List <BasketLine>();
basketLines.Add(CreateNewBasketLine(basketItems, productAvailability));
var basket = new Basket()
{
UserId = basketItems.UserId,
CreatedDate = DateTime.UtcNow,
BasketLines = basketLines,
IsActive = true,
IsOrdered = false,
UpdateDate = DateTimeProvider.Instance.GetUtcNow()
};
return(basket);
}
public void Update(ProductAvailabilityDto item, bool save = true)
{
// Get existing object from database
ProductAvailability oldItem = GetFromModel().FirstOrDefault(x => x.Id.Equals(item.Id));
// Set the new values for the fetched object
if (oldItem != null)
{
oldItem.IsAvailable = item.IsAvailable;
oldItem.Date = item.Date;
oldItem.ProductId = item.ProductId;
}
if (save)
{
Context.SaveChanges();
}
}
/*Add New Product Detail*/
public ServiceResponse SaveProduct(ProductModel productModel)
{
var product = new Product();
var productAccountPrice = new ProductAccountPrice();
var productAvailability = new ProductAvailability();
var productPricing = new ProductPricing();
Mapper.Map(productModel, product);
Mapper.Map(productModel.ProductAccountPriceModel, product.ProductAccountPrice);
Mapper.Map(productModel.ProductAvailabilityModel, product.ProductAvailability);
Mapper.Map(productModel.ProductPricingModel, product.ProductPricing);
Mapper.Map(productModel.ProductDivisionModel, product.ProductDivision);
Mapper.Map(productModel.ProductCategoryModel, product.ProductCategory);
Mapper.Map(productModel.ProductAttributeModel, product.ProductAttribute);
product.CreatedBy = GetLoginUserId();
product.ProductAccountPrice.ToList().ForEach(m => m.CreatedBy = GetLoginUserId());
product.ProductPricing.ToList().ForEach(m => m.CreatedBy = GetLoginUserId());
_unitOfWork.productRespository.Insert(product);
_unitOfWork.Save();
Mapper.Map(product, productModel);
Mapper.Map(product.ProductClass, productModel.ProductClassModel);
Mapper.Map(product.ProductAccountPrice, productModel.ProductAccountPriceModel);
Mapper.Map(product.ProductAvailability, productModel.ProductAvailabilityModel);
Mapper.Map(product.ProductPricing, productModel.ProductPricingModel);
Mapper.Map(product.ProductDivision, productModel.ProductDivisionModel);
Mapper.Map(product.ProductCategory, productModel.ProductCategoryModel);
Mapper.Map(product.ProductAttribute, productModel.ProductAttributeModel);
return new ServiceResponse { Success = true, Message = "Saved", Data = productModel };
}
public BasketLine CreateNewBasketLine(AddProductToBasketRequestModel basketItems, ProductAvailability productAvailability)
{
var basketLine = new BasketLine()
{
ProductId = basketItems.ProductId,
Quantity = basketItems.Quantity,
StockId = productAvailability.StockId,
GiftNote = basketItems.GiftNote
};
return(basketLine);
}
public void When_Product_Is_Null_It_Should_Return_Product_Is_Not_Available(int productId, ProductAvailability expected)
{
//ProductResponseModel productResponseModel = null;
//var productAvailability = CheckProductIsAvailable(addProductToBasketRequestModel);
//var productRepositoryMock = new Mock<IProductService>();
//productRepositoryMock.Setup(p => p.GetProduct(new Models.Product.ProductRequestModel() { ProductId = 1000})).Returns(productResponseModel);
//var productResponse = _productService.GetProduct(new Models.Product.ProductRequestModel() { ProductId = 10 });
}
public async Task WhenICallTheProductAvailabilityAPIForProductId(string productId)
{
productAvailability = await apiClient.ProductAPI.ListProductAvailabilityAsync(productId).ConfigureAwait(false);
}
