public async Task <ServiceResponse <GetProductDto> > AddProduct(AddProductDto newProduct)
{
var products = await _dbContext.Products.FirstOrDefaultAsync(x => x.Name == newProduct.Name);
if (products != null)
{
return(ResponseResult.Failure <GetProductDto>("product duplicate."));
}
var product = new Product
{
Name = newProduct.Name,
Price = newProduct.Price,
StockCount = newProduct.StockCount,
ProductGroupId = newProduct.ProductGroupId
};
_dbContext.Products.Add(product);
await _dbContext.SaveChangesAsync();
var productToReturn = await _dbContext.Products
.Include(x => x.ProductGroup)
.Where(x => x.Id == product.Id)
.FirstOrDefaultAsync();
var dto = _mapper.Map <GetProductDto>(productToReturn);
return(ResponseResult.Success(dto));
}
public async Task <int> Add(AddProductDto addProductDto)
{
await ThrowExceptionIfProductCodeIsAlreadyExists(addProductDto.ProductCode);
await ThrowExceptionIfProductTitleIsAlreadyExistsInProductCategory(addProductDto.Title);
await ThrowExceptionIfProductCategoryNotExists(addProductDto.ProductCategoryId);
var product = new Product
{
Title = addProductDto.Title,
MinimumStock = addProductDto.MinimumStock,
ProductCode = addProductDto.ProductCode,
ProductCategoryId = addProductDto.ProductCategoryId
};
var warehouseItems = new HashSet <WarehouseItem>
{
new WarehouseItem
{
ProductId = product.Id
}
};
product.WarehouseItems = warehouseItems;
_repository.Add(product);
await _unitOfWork.CompleteAsync();
return(product.Id);
}
public async Task <Guid> AddProductAsync(AddProductDto productDtos)
{
//Automapper
var product = ProductConverter.Convert(productDtos);
return(await _productRepository.AddProductAsync(product));
}
public async Task When_Adding_Product_Then_Adds_Product_To_Category(AddProductDto dto, string imagesPath)
{
// Arrange
var category = CreateProductCategory(false);
productCategoryRepositoryMock.Setup(x => x.GetAndEnsureExistAsync(It.IsAny <Guid>()))
.ReturnsAsync(category);
pathManagerMock.Setup(x => x.GetProductPath(It.IsAny <string>(), It.IsAny <string>()))
.Returns(imagesPath);
// Act
await sut.AddAsync(dto);
// Assert
category.Products.Should().HaveCount(1);
var product = category.Products.First();
product.Name.Should().Be(dto.Name);
product.NameEng.Should().Be(dto.NameEng);
product.Price.Should().Be(dto.Price);
product.Description.Should().Be(dto.Description);
product.DescriptionEng.Should().Be(dto.DescriptionEng);
product.AcceptCharms.Should().Be(dto.AcceptCharms);
product.Sizes.Should().Be(dto.Sizes);
product.ImagesPath.Should().Be(imagesPath);
}
public async Task <IActionResult> AddProductAsync([FromBody] AddProductDto request)
{
try
{
var addProductCommand = new AddProductCommand(request.ProductName, request.ProductDisplayName, request.PublisherId, request.PrintIssn,
request.OnlineIssn, request.ProductTypeCode, request.ProductStatusCode, request.PublisherProductCode, request.LegacyIdSpid);
await _mediator.Send(addProductCommand);
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(ex, "Something went wrong in AddProductAsync");
var errorResponse = new ProblemDetails()
{
Title = "An unexpected error occurred. Please try again later.",
Status = StatusCodes.Status500InternalServerError,
Detail = ex.Message
};
return(StatusCode(StatusCodes.Status500InternalServerError, errorResponse));
}
}
public async Task <ProductEntity> AddProduct(AddProductDto productDto)
{
if (await Db.ProductEntities.AnyAsync(x => x.VendorCode == productDto.VendorCode))
{
return(null);
}
var country = await GetOrCreateCountryAsync(productDto.Country);
var brand = await GetOrCreateBrandAsync(productDto.BrandName);
var category = await GetOrCreateCategoryAsync(productDto.CategoryTypeId);
var color1Id = productDto.ColorIds.GetValueOrDefault(0, -1);
var color2Id = productDto.ColorIds.GetValueOrDefault(1, -1);
var color3Id = productDto.ColorIds.GetValueOrDefault(2, -1);
var color4Id = productDto.ColorIds.GetValueOrDefault(3, -1);
var color5Id = productDto.ColorIds.GetValueOrDefault(4, -1);
var color6Id = productDto.ColorIds.GetValueOrDefault(5, -1);
var color7Id = productDto.ColorIds.GetValueOrDefault(6, -1);
var product = new ProductEntity
{
BrandId = brand.BrandId,
PrintTypeId = productDto.PrintTypeId,
ExtraPrintTypeId = productDto.ExtraPrintTypeId,
CategoryId = category.CategoryId,
ClicksCount = 0,
ShopColorId = productDto.ShopColorId,
ShopTypeId = productDto.ShopTypeId,
Color1Id = color1Id,
Color2Id = color2Id,
Color3Id = color3Id,
Color4Id = color4Id,
Color5Id = color5Id,
Color6Id = color6Id,
Color7Id = color7Id,
CreatedDate = DateTime.UtcNow,
Description = "",
IsAvailable = true,
IsDeleted = false,
Link = productDto.Link,
MadeInCountryId = country.CountryId,
PreviewPhotoId = 0,
Price = productDto.Price,
VendorCode = productDto.VendorCode
};
Db.ProductEntities.Add(product);
await Db.SaveChangesAsync();
var photos = await AddProductPhotos(product.ProductId, productDto.Photos);
product.PreviewPhotoId = photos.FirstOrDefault()?.ProductPhotoId ?? 0;
await Db.SaveChangesAsync();
await AddProductSizes(product.ProductId, productDto.Sizes);
return(product);
}
public async Task <bool> Add(AddProductDto product)
{
try
{
var entity = await _uow.Product.Get(p => p.Code == product.Code);
if (entity != null)
{
return(false);
}
await _uow.Product.Add(new Data.Models.Product
{
Code = product.Code,
Name = product.Name,
Picture = product.Picture,
Price = product.Price,
UpdatedAt = product.UpdatedAt
});
return(await _uow.CompleteAsync());
}
catch (Exception ex)
{
return(false);
}
}
public bool AddNewProduct(AddProductDto newProduct)
{
using (var db = new SqlConnection(_connectionString))
{
var sql = @"
INSERT INTO [Product]
([Title]
,[SellerId]
,[ImgUrl]
,[TypeId]
,[Description]
,[CategoryId]
,[Price]
,[QuantityInStock])
VALUES
(@title,
@sellerId,
@imgUrl,
@typeId,
@description,
@categoryId,
@price,
@quantityInStock
)";
return(db.Execute(sql, newProduct) == 1);
}
}
public void AddProduct(AddProductDto addProduct)
{
if (addProduct.CategoryIds == null || !addProduct.CategoryIds.Any())
{
throw new BusinessException("Lütfen önce kategori seçiniz.");
}
var product = new Product
{
Name = addProduct.Name,
Description = addProduct.Description,
Image = addProduct.MainPhoto,
ProductImage = addProduct.Photos,
IsActive = addProduct.IsActive,
Price = addProduct.Price
};
_uow.Product.Insert(product);
var productCategories = _uow.Category.Table
.Where(c => addProduct.CategoryIds.Contains(c.Id))
.Select(e => new ProductToCategory
{
CategoryId = e.Id,
Product = product
}).ToList();
_uow.ProductToCategory.Insert(productCategories);
_uow.SaveChanges();
}
public async Task <bool> AddProduct(AddProductDto productdto)
{
Product adedproduct = productdto.Adapt <Product>();
await _context.Products.AddAsync(adedproduct);
await _context.SaveChangesAsync();
if (!await _categoryManager.AddProductCategoryRelation(productdto.CategoryId, adedproduct.ProductId))
{
throw new Exception("Product And Category Relation Requried");
}
if (!await _stockManager.SetStockPropertyCombination(productdto.CategoryId, adedproduct.ProductId))
{
throw new Exception("Product Variation Requried");
}
if (!await AddProductImages(productdto.Images, adedproduct.ProductId))
{
throw new Exception("Product Images Requried");
}
//ProductElasticIndexDto productElasticIndexDto = new ProductElasticIndexDto();
//productElasticIndexDto.Adapt(adedproduct);
//await CreateIndexes(productElasticIndexDto);
return(await Task.FromResult <bool>(true));
}
public IResult Confirm(AddProductDto addProductDto)
{
var result = _addProductDal.Get(a => a.Id == addProductDto.AddProductId); //id üzerinden veritabanından çekiliyor
if (result.Status) //zaten onaylı ise hata döndürüyor
{
return(new ErrorResult());
}
result.Status = true; //onaylandı olarak işaretleniyor
var product = _productService.IsThereAnyProduct(result).Data; //üründen var mı kontrolü
if (product != null) //varsa
{
product.Quantity += result.Quantity; //miktarı ekleniyor
_productService.Update(product); //ürün güncelleniyor
}
else
{
product = new Product //yoksa yeni ürün ekleniyor
{
Quantity = result.Quantity,
UnitPrice = addProductDto.UnitsInPrice,
SupplierId = result.SupplierId,
CategoryId = result.CategoryId
};
_productService.Add(product);
}
_addProductDal.Update(result);
_wantService.Want(product);//yeni ürün eklendiği için want servise gönderiliyor
return(new SuccessResult("onaylandı"));
}
private void btnAdd_Click(object sender, EventArgs e)
{
var name = this.tbName.Text;
var discountinued = this.chbDiscountinued.Checked;
var categoryId = this.cbCategory.SelectedValue;
var supplierId = this.cbSupplier.SelectedValue;
//var name = this.tbName.Text;
//var discountinued = this.tbDiscountinued.Text;
//var categoryId = this.cbCategory.SelectedValue;
//var supplierId = this.cbSupplier.SelectedValue;
var addProductDto = new AddProductDto
{
Name = name,
Discountinued = discountinued,
CategoryId = (int)categoryId,
SupplierId = (int)supplierId
};
var op = new insertProductOperation(addProductDto);
var result = OperationManager.Instance.ExecuteOperation(op);
if (!result.Errors.Any())
{
MessageBox.Show("Successfuly added!");
RefreshGrid();
}
else
{
MessageBox.Show(result.Errors.First());
}
}
private void btnSubmit_Click(object sender, EventArgs e)
{
var productZaUpdate = new AddProductDto
{
Id = dto.Id,
Name = name.Text,
SupplierId = (ddlSupplier.SelectedItem as SupplierDto).Id,
CategoryId = (ddlCategory.SelectedItem as CategoryDto).Id,
Price = price.Value,
Quantity = (int)quantity.Value
};
var updateOp = new OpProductUpdate(productZaUpdate);
var rezOp = OperationManager.Instance.ExecuteOp(updateOp);
if (rezOp.Success)
{
MessageBox.Show("Uspesno izmenjeno");
this.Dispose();
}
else
{
MessageBox.Show(rezOp.Errors.FirstOrDefault().ToString());
}
}
public async Task <ServiceResponse <GetProductDto> > AddProduct(AddProductDto newProduct)
{
try
{
var product = await _dbContext.Products.Include(x => x.ProductGroup).FirstOrDefaultAsync(x => x.Name == newProduct.Name);
if (!(product is null))
{
return(ResponseResult.Failure <GetProductDto>($"Product Name = {newProduct.Name} already exists."));
}
var productGroup = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == newProduct.ProductGroupId);
if (productGroup is null)
{
return(ResponseResult.Failure <GetProductDto>($"ProductGroup Id = {newProduct.ProductGroupId} not found."));
}
product = _mapper.Map <Product>(newProduct);
product.CreatedById = Guid.Parse(GetUserId());
product.ProductGroup = productGroup;
_dbContext.Products.Add(product);
await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductDto>(product);
return(ResponseResult.Success(dto));
}
catch (Exception ex)
{
return(ResponseResult.Failure <GetProductDto>(ex.Message));
}
}
public async Task <ServiceResponse <GetProductDto> > AddProduct(AddProductDto newProduct)
{
var productGroup = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == newProduct.ProductGroupId);
if (productGroup == null)
{
return(ResponseResult.Failure <GetProductDto>("Product Group Not Found."));
}
var _product = new mProduct
{
Name = newProduct.Name,
Price = newProduct.Price,
StockCount = newProduct.StockCount,
CreateBy = GetUsername(),
CreateDate = Now(),
Status = true,
ProductGroupId = newProduct.ProductGroupId,
ProductGroup = productGroup
};
_dbContext.Products.Add(_product);
await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductDto>(_product);
return(ResponseResult.Success(dto));
}
public async Task <bool> Update(AddProductDto product)
{
try
{
var entity = await _uow.Product.Get(p => p.Code == product.Code);
if (entity == null)
{
return(false);
}
entity.Name = product.Name;
entity.Picture = product.Picture;
entity.Price = product.Price;
entity.UpdatedAt = DateTime.Now;
await _uow.Product.Update(entity);
return(await _uow.CompleteAsync());
}
catch (Exception ex)
{
return(false);
}
}
public void Add(AddProductDto dto)
{
var product = _mapper.Map <Product>(dto);
ValidateProduct(product);
productMongoRepository.Add(product);
}
public Task <ApiResponse <string> > AddProduct([FromBody] AddProductDto productDto)
{
return(Catch(async() =>
{
var command = new AddProductCommand(productDto);
var result = await MessageBus.DispatchCommand(command);
return result.Payload;
}));
}
public IActionResult ConfirmAaddProduct(AddProductDto addProductDto)
{
var result = _addProductService.Confirm(addProductDto);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IActionResult RejectAaddProduct(AddProductDto addProductDto)
{
var result = _addProductService.Reject(addProductDto.AddProductId);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public async Task <IActionResult> EditProduct(int productId, AddProductDto addProductDto)
{
var product = _productsContext.Products
.Include(x => x.Attributes)
.FirstOrDefault(x => x.Id == productId);
// todo validation
if (product == null)
{
return(NotFound());
}
var category = _productsContext.Categories.FirstOrDefault(x => x.Id == addProductDto.CategoryId);
if (category == null)
{
return(BadRequest("Category not found"));
}
var attributeIds = addProductDto.Attributes.Select(y => y.AttributeId).ToList();
var attributes = _productsContext.Attributes
.Where(x => attributeIds.Contains(x.Id)).ToList();
var notFoundAttributes = addProductDto.Attributes.Where(x => attributes.All(y => y.Id != x.AttributeId));
if (notFoundAttributes.Any())
{
return(BadRequest("Attributes not found"));
}
product.Name = addProductDto.Name;
product.Description = addProductDto.Description;
product.Price = addProductDto.Price;
product.CategoryId = addProductDto.CategoryId;
product.Category = category;
product.IsActive = addProductDto.IsActive;
product.Attributes = addProductDto.Attributes.Select(x => new AttributeValue()
{
AttributeId = x.AttributeId,
Value = x.AttributeValue,
Attribute = attributes.First(y => y.Id == x.AttributeId)
}).ToList();
await _productsContext.SaveChangesAsync();
var productDto = ToProductDto(product);
await _bus.Publish(new ProductUpdatedEvent()
{
ProductDetails = productDto,
UpdateDateUtc = DateTime.UtcNow
});
return(Created($"api/products/{product.Id}", productDto)); // todo references not initialized
}
public async Task <ServiceResponse <List <GetProductDto> > > AddProduct(AddProductDto newProduct)
{
try
{
_log.LogInformation("Start process.");
var product = await _dBContext.Products
.Include(x => x.ProductGroup)
.FirstOrDefaultAsync(x => x.Name == newProduct.Name);
if (!(product is null))
{
var msg = $"Duplicate name exists.";
_log.LogError(msg);
return(ResponseResult.Failure <List <GetProductDto> >(msg));
}
_log.LogInformation("Check ProductGroup.");
var productGroup = await _dBContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == newProduct.ProductGroupId);
if (productGroup is null)
{
var msg = $"Product Group not exists.";
_log.LogError(msg);
return(ResponseResult.Failure <List <GetProductDto> >(msg));
}
_log.LogInformation("Add New Product.");
var addProduct = new Models.Product
{
Name = newProduct.Name,
Price = newProduct.Price,
StockCount = newProduct.StockCount,
ProductGroupId = newProduct.ProductGroupId
};
_dBContext.Products.Add(addProduct);
await _dBContext.SaveChangesAsync();
_log.LogInformation("Success.");
var productAll = await _dBContext.Products
.Include(x => x.ProductGroup)
.ToListAsync();
var dto = _mapper.Map <List <GetProductDto> >(productAll);
_log.LogInformation("End process.");
return(ResponseResult.Success(dto));
}
catch (System.Exception ex)
{
_log.LogError(ex.Message);
return(ResponseResult.Failure <List <GetProductDto> >(ex.Message));
}
}
public IActionResult AddProduct(AddProductDto newProduct)
{
if (_repo.AddNewProduct(newProduct))
{
return(Created($"ProductId/{newProduct.Title}", newProduct));
}
else
{
return(BadRequest());
}
}
public async Task <ServiceResponse <List <GetProductDto> > > AddProduct(AddProductDto newProduct)
{
ServiceResponse <List <GetProductDto> > serviceResponse = new ServiceResponse <List <GetProductDto> >();
Product product = _mapper.Map <Product>(newProduct);
await _context.Products.AddAsync(product);
await _context.SaveChangesAsync();
serviceResponse.Data = (_context.Products.Select(p => _mapper.Map <GetProductDto>(p))).ToList();
return(serviceResponse);
}
public async Task <IActionResult> Post([FromBody] AddProductDto model)
{
if (model == null)
{
return(BadRequest("Product is missing"));
}
var product = await _productService.AddProductAsync(model);
return(Ok(product));
}
public async Task AddAsync(AddProductDto product)
{
var category = await categoryRepository.FindASync(product.CategoryId);
if (category == null)
{
throw new CategoryNotFoundException("Category not found");
}
var p = new Product(product.Name, product.Description, product.Price, category);
await productsRepository.AddAsync(p);
}
public async Task <IActionResult> AddProduct(AddProductDto newproduct)
{
try
{
return(Ok(await _productService.AddProduct(newproduct)));
}
catch (Exception)
{
_logger.LogError("Failed to execute POST");
return(BadRequest());
}
}
public async Task When_Adding_Product_Then_Gets_Category_From_Repository(AddProductDto dto)
{
// Arrange
productCategoryRepositoryMock.Setup(x => x.GetAndEnsureExistAsync(It.IsAny <Guid>()))
.ReturnsAsync(CreateProductCategory(false));
// Act
await sut.AddAsync(dto);
// Assert
productCategoryRepositoryMock.Verify(x => x.GetAndEnsureExistAsync(dto.ProductCategoryId), Times.Once);
}
public static Product Convert(AddProductDto addProductDto)
{
var product = new Product
{
ProductName = new MultilingualString()
};
foreach (var productDto in addProductDto.Data)
{
product.ProductName.SetTranslation(productDto.CultuleName, productDto.Value.Name);
}
return(product);
}
public UpdateProductForm(AddProductDto dto)
{
InitializeComponent();
if (dto == null)
{
throw new ArgumentException("Morate izabrati proizvod za update");
}
this.dto = dto;
InitializeFormItems();
}
