public async Task <IActionResult> Post(string customerId, [FromBody] AddItemDto item)
{
if (item == null)
{
return(ResponseMessage.BadRequest(Status.UnexpectedError, UnexpectedError));
}
var validator = new AddItemValidator();
var results = validator.Validate(item);
if (!results.IsValid)
{
var error = results.Errors.FirstOrDefault();
return(ResponseMessage.BadRequest(error.ErrorCode, error.ErrorMessage));
}
var actor = (PID)shoppingListsActorProvider.ActorInstance;
var @event = await actor.RequestAsync <ShoppingListEvent>(new AddItem(customerId, item.Name, item.Quantity));
switch (@event.Status)
{
case Status.ItemAdded: return(ResponseMessage.CreatedAtAction("Get", "ShoppingLists", new { name = item.Name }, @event.Status, ItemAdded));
case Status.QuantityUpdated: return(ResponseMessage.Ok(@event.Status, ItemUpdatedWithNewQuantity));
default: return(ResponseMessage.BadRequest(@event.Status, UnexpectedError));
}
}
public async Task <AddItemResultDto> AddItemToBasket(AddItemDto dto, string buyerId)
{
bool inStock = _stockService.IsItInStock(dto.Sku, dto.Quantity);
if (!inStock)
{
throw new WarningNotificationException("The product is out of stock.", "999");
}
var basket = await _basketRepository.FindOneAsync(p => p.BuyerId == buyerId);
if (basket == null)
{
basket = new Basket(buyerId);
basket.AddItem(dto.CatalogItemId, dto.Sku, dto.Price, dto.Quantity);
await _basketRepository.InsertOneAsync(basket);
}
else
{
basket.AddItem(dto.CatalogItemId, dto.Sku, dto.Price, dto.Quantity);
await _basketRepository.UpdateOneAsync(basket);
}
int itemCount = basket.Items.GroupBy(p => p.CatalogItemId).Count();
return(new AddItemResultDto {
ItemCount = itemCount
});
}
public async Task AddItemToBasket_Should_Return_Ok_With_ItemCount_When_Insert_Success()
{
var expectedStatusCode = HttpStatusCode.OK;
//Arrange
var request = new AddItemDto
{
CatalogItemId = "H22",
Sku = "H22XSB",
Price = 22,
Quantity = 2
};
var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
// Act
var response = await _client.PostAsync("/api/v1/ShoppingBasket/AddItemToBasket", content);
var actualStatusCode = response.StatusCode;
var actualResult = await response.Content.ReadAsStringAsync();
var actualResultJson = JsonConvert.DeserializeObject <AddItemResultDto>(actualResult);
// Assert
Assert.Equal(expectedStatusCode, actualStatusCode);
Assert.Equal(1, actualResultJson.ItemCount);
}
public ActionResult Additem()
{
var model = new AddItemDto {
Categories = _categoryService.GetCategoryList()
};
return(View(model));
}
public async Task <Item> AddItemAsync(AddItemDto model)
{
var userId = long.Parse(_httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
var itemToAdd = model.ToItem(userId);
var item = (await _itemService.InsertAsync(itemToAdd));
//var item = (await _itemService.InsertAsync(itemToAdd)).ToBoardReturnDto();
return(item);
}
public IActionResult AddItem([FromBody] AddItemDto item)
{
var res = Service.ShoppingCart.ShoppingCart.AddItem(item, _context);
if (res == null)
{
return(new OkObjectResult(new { error = "No object created" }));
}
return(new OkObjectResult(res));
}
public async Task <ActionResult> CreateItem(AddItemDto addItemDto)
{
var itemToAdd = _mapper.Map <Entities.Item>(addItemDto);
await _beachBuddyRepository.AddItem(itemToAdd);
await _beachBuddyRepository.Save();
var itemToReturn = _mapper.Map <ItemDto>(itemToAdd);
return(CreatedAtRoute("GetItem", new { itemId = itemToReturn.Id }, itemToReturn));
}
public ActionResult AddItem(AddItemDto model)
{
if (ModelState.IsValid)
{
var itemId = _itemService.AddItem(model);
return(RedirectToAction("ItemDetails", "Item", _itemService.ItemDetails(itemId)));
}
model.Categories = _categoryService.GetCategoryList();
return(View(model));
}
public IActionResult Post([FromBody] AddItemDto model)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(Response(model));
}
_itemService.Add(model);
return(Response(model));
}
public async Task <IActionResult> UpdateItem(AddItemDto newItem)
{
var serviceResponse = await _itemService.UpdateItem(newItem);
if (serviceResponse.Success == false)
{
return(NotFound(serviceResponse));
}
else
{
return(Ok(serviceResponse));
}
}
public async Task <ServiceResponse <List <GetItemDto> > > AddItem(AddItemDto newItem)
{
ServiceResponse <List <GetItemDto> > serviceResponse = new ServiceResponse <List <GetItemDto> >();
await _context.Items.AddAsync(_mapper.Map <Item>(newItem));
await _context.SaveChangesAsync();
List <GetItemDto> items = await(_context.Items.Select(c => _mapper.Map <GetItemDto>(c))).ToListAsync();
serviceResponse.Data = items;
return(serviceResponse);
}
//public static Item ToItem(this AddItemDto model, long personId)
//{
// var board = new Item
// {
// Name = model.Name,
// Description = model.Description,
// Img = model.Img,
// IsPrivate = model.IsPrivate,
// CreatedBy = personId,
// User = {Id = personId}
// };
// return board;
//}
public static Item ToItem(this AddItemDto model, long sellerId)
{
var item = new Item
{
Name = model.Name,
Description = model.Description,
Cost = model.Cost,
NumberOfParticipants = model.ParticipantsNumber,
CreatedBy = sellerId,
//Seller = {Id = sellerId}
};
return(item);
}
public AddItemDto ItemDetailsToAdd(int itemId)
{
var itemDetails = ItemDetails(itemId);
AddItemDto itemToEdit = new AddItemDto
{
Name = itemDetails.Name,
Description = itemDetails.Description,
PricePerOne = itemDetails.PricePerOne,
NumberOfItem = itemDetails.NumberOfItem,
CategoryId = itemDetails.CategoryId,
ItemId = itemDetails.ItemId
};
return(itemToEdit);
}
public async Task <IActionResult> AddItem(
AddItemDto model
)
{
try
{
var responsePayload = await _itemService.AddItemAsync(model);
return(Ok(responsePayload));
}
catch (Exception ex)
{
return(BadRequest(new { ex.Message }));
}
}
public async Task <ServiceResponse <GetItemDto> > UpdateItem(AddItemDto newItem)
{
ServiceResponse <GetItemDto> serviceResponse = new ServiceResponse <GetItemDto>();
var item = await _context.Items.FirstOrDefaultAsync(x => x.Id == _mapper.Map <Item>(newItem).Id);
if (item == null)
{
serviceResponse.Success = false;
serviceResponse.Message = "Item not found";
}
else
{
item.Name = newItem.Name;
item.Type = newItem.Type;
_context.Items.Update(item);
await _context.SaveChangesAsync();
serviceResponse.Data = _mapper.Map <GetItemDto>(item);
}
return(serviceResponse);
}
public int AddItem(AddItemDto model)
{
var item = new Item
{
Name = model.Name,
NumberOfItem = model.NumberOfItem,
CategoryId = model.CategoryId,
Description = model.Description,
PricePerOne = model.PricePerOne
};
var result = _database.Items.Add(item);
var image = new Image
{
ImagePath = _fileManager.SaveFile(model.File),
ItemId = result.Id
};
_database.Images.Add(image);
_database.SaveChanges();
return(result.Id);
}
public static ShoppingCartItem AddItem(AddItemDto item, eCommerceContext _context)
{
if (!_context.Product.Any(x => x.ProductId == item.ProductId))
{
return(null);
}
if (item.Quantity <= 0)
{
return(null);
}
API.Models.ShoppingCart cart = _context.ShoppingCart.FirstOrDefault(x => x.ShoppingCartId == item.ShoppingCartID);
if (cart == null)
{
cart = new API.Models.ShoppingCart()
{
LastUpdated = DateTime.Now
}
}
;
var cartItem = new ShoppingCartItem()
{
ProductId = item.ProductId ?? 0,
Quantity = item.Quantity ?? 0
};
cart.ShoppingCartItem = new[] { cartItem };
_context.SaveChanges();
return(cartItem);
}
}
public void AddItemToBasket_Should_Return_ItemCount([Frozen] Mock <IMongoRepository <Basket> > basketRepository,
[Frozen] Mock <IStockService> stockService,
AddItemDto addItemDto,
string buyerId,
BasketService sut
)
{
Basket basket = new Basket(buyerId);
basketRepository.Setup(r => r.FindOneAsync(p => p.BuyerId == buyerId)).ReturnsAsync(basket);
basketRepository.Setup(r => r.UpdateOneAsync(basket));
stockService.Setup(s => s.IsItInStock(addItemDto.Sku, addItemDto.Quantity)).Returns(true);
Func <Task> action = async() =>
{
var result = await sut.AddItemToBasket(addItemDto, buyerId);
result.Should().BeEquivalentTo(new AddItemResultDto {
ItemCount = 1
});
};
action.Should().NotThrow <Exception>();
}
public async Task <IActionResult> AddItemToBasket([FromBody] AddItemDto dto)
{
var result = await _basketService.AddItemToBasket(dto, UserId);
return(Ok(result));
}
public async Task <IActionResult> AddItem(AddItemDto newItem)
{
return(Ok(await _itemService.AddItem(newItem)));
}
public void Add(AddItemDto item)
{
var addCommand = _mapper.Map <AddNewItemCommand>(item);
_bus.SendCommand(addCommand);
}
