public async Task ReturnsOk_SetsDiscountOnItem()
{
var repository = new InMemoryItemRepository();
var readRepository = new InMemoryItemReadRepository();
repository.EventOccurred += async entity => await new ItemReadModelHandler(readRepository).Handle(entity.NewEvents.ToList <object>());
var itemController =
new ItemController(repository, readRepository)
.BootstrapForTests();
var postNewPotatoItemDto = new PostRequestDto
{
Code = "potato",
Price = 30
};
var postNewPotatoResult = await itemController.Post(postNewPotatoItemDto);
var potatoDto = (ItemDto)postNewPotatoResult.Value;
var postSetDiscountDto = new SetDiscountRequestDto
{
PercentOff = 10
};
var result = await itemController.SetDiscount(potatoDto.Id, postSetDiscountDto);
Assert.Equal((int)HttpStatusCode.OK, result.StatusCode);
var potatoItemDto = (ItemDto)result.Value;
Assert.Equal(10, potatoItemDto.PercentOff);
}
public async Task RespondsWithCreated_PostNewCoupon()
{
var couponRepository = new InMemoryCouponRepository();
var couponController =
new CouponController(couponRepository)
.BootstrapForTests(urlHelper: new ActionNameOnlyUrlHelper());
var postRequestDto = new PostRequestDto
{
Code = "GRAND_SALE",
PercentOff = 50
};
var postResponse = (CreatedResult)await couponController.Post(postRequestDto);
Assert.Equal((int)HttpStatusCode.Created, postResponse.StatusCode);
var couponDto = (CouponDto)postResponse.Value;
Assert.Equal(nameof(CouponController.Get), postResponse.Location);
Assert.Equal("GRAND_SALE", couponDto.Code);
Assert.Equal(50, couponDto.PercentOff);
}
public async Task CanGetItem_PostNewItem()
{
var repository = new InMemoryItemRepository();
var readRepository = new InMemoryItemReadRepository();
repository.EventOccurred += async entity => await new ItemReadModelHandler(readRepository).Handle(entity.NewEvents.ToList <object>());
var itemController =
new ItemController(repository, readRepository)
.BootstrapForTests();
var postNewItemDto = new PostRequestDto
{
Code = "lettuce"
};
await itemController.Post(postNewItemDto);
var anotherItemController =
new ItemController(repository, readRepository)
.BootstrapForTests();
var result = await anotherItemController.GetByItemCode("lettuce");
Assert.Equal((int)HttpStatusCode.OK, result.StatusCode);
var itemDto = (ItemDto)result.Value;
Assert.Equal("lettuce", itemDto.Code);
}
public async Task RespondsWithCreated_PostNewItem()
{
var repository = new InMemoryItemRepository();
var readRepository = new InMemoryItemReadRepository();
repository.EventOccurred += async entity => await new ItemReadModelHandler(readRepository).Handle(entity.NewEvents.ToList <object>());
var itemController =
new ItemController(repository, readRepository)
.BootstrapForTests();
var itemTypeId = Guid.NewGuid();
var postNewItemDto = new PostRequestDto
{
Code = "lettuce",
ItemTypeId = itemTypeId
};
var result = await itemController.Post(postNewItemDto);
Assert.Equal((int)HttpStatusCode.Created, result.StatusCode);
var itemDto = (ItemDto)result.Value;
Assert.Equal("lettuce", itemDto.Code);
Assert.Equal(itemTypeId, itemDto.ItemTypeId);
}
public PostResponseDto Create(PostRequestDto request)
{
var userId = _userService.GetCurrentUserId();
var categories = _db.Categories
.Where(category => request.Categories.Contains(category.Id))
.Select(category => new PostCategory {
Category = category
})
.ToList();
var post = new Post
{
Title = request.Title,
Description = request.Description,
Content = request.Content,
MainPhoto = request.MainPhoto,
Categories = categories,
Photos = request.Photos.Select(src => new Photo {
Src = src
}).ToList(),
UserId = userId
};
_db.Posts.Add(post);
_db.SaveChanges();
_userActivityService.Track($"Created post: {post.Title}");
return(_mapper.Map <PostResponseDto>(post));
}
public async Task <ActionResult <PostDto> > UpdatePost(PostRequestDto postRequestDto)
{
postRequestDto.CreatedDate = DateTime.Now;
var postUpdated = await _postRepository.UpdatePostAsync(_mapper.Map <PostRequestDto, Post>(postRequestDto));
return(Ok(_mapper.Map <Post, PostDto>(postUpdated)));
}
public async Task CanGetCoupon_PostNewCoupon()
{
var couponRepository = new InMemoryCouponRepository();
var couponController =
new CouponController(couponRepository)
.BootstrapForTests();
var postRequestDto = new PostRequestDto
{
Code = "GRAND_SALE",
PercentOff = 50
};
var postResponse = await couponController.Post(postRequestDto);
var postResponseCouponDto = (CouponDto)postResponse.Value;
var getResponse = await couponController.Get(postResponseCouponDto.Id);
Assert.Equal((int)HttpStatusCode.OK, getResponse.StatusCode);
var couponDto = (CouponDto)getResponse.Value;
Assert.Equal("GRAND_SALE", couponDto.Code);
Assert.Equal(50, couponDto.PercentOff);
}
public ActionResult <Guid> Post(
PostRequestDto dto)
{
var(linkString, saveAsFileName) = dto;
var linkResult = Link.Create(linkString);
if (linkResult.IsFailure)
{
return(BadRequest(linkResult.Error));
}
var link = linkResult.Value;
var saveAsFileResult =
SaveAsFile.Create(
link,
_completedDownloadsDirectory,
saveAsFileName);
if (saveAsFileResult.IsFailure)
{
return(BadRequest(saveAsFileResult.Error));
}
var job =
_notificationsManager.AddNotificationEventHandlers(
_downloadManager.CreateDownloadJob(link, saveAsFileResult.Value));
var(_, isFailure, error) = _downloadStarter.Start(job);
return(isFailure ? Problem(error) : Ok(job.Id.Value));
}
public async Task RespondsWithCreated_PostNewItemType()
{
var itemTypeRepository = new InMemoryItemTypeRepository();
var itemTypeReadRepository = new InMemoryItemTypeReadRepository();
itemTypeRepository.EventOccurred += entity => itemTypeReadRepository.UpdateAsync(new ItemTypeReadModel
{
Id = entity.Id,
Code = entity.Code
});
var itemTypeController =
new ItemTypeController(itemTypeRepository, itemTypeReadRepository)
.BootstrapForTests(urlHelper: new ActionNameOnlyUrlHelper());
var postRequestDto = new PostRequestDto
{
Code = "fruit"
};
var postResponse = (CreatedResult)await itemTypeController.Post(postRequestDto);
Assert.Equal((int)HttpStatusCode.Created, postResponse.StatusCode);
var itemTypeDto = (ItemTypeDto)postResponse.Value;
Assert.Equal(nameof(ItemTypeController.Get), postResponse.Location);
Assert.Equal("fruit", itemTypeDto.Code);
}
public void EditPost(PostRequestDto postRequestDto)
{
var post = GetById(postRequestDto.Id);
post.Id = postRequestDto.Id;
post.Title = postRequestDto.Title;
post.Content = postRequestDto.Content;
}
private PostRequestDto GetPostParam(SalesforceRequestDto salesforceParam, string salesforcelUrl)
{
var postParam = new PostRequestDto()
{
Url = salesforcelUrl,
RequestData = GetRequestData(salesforceParam),
TokenValue = GetTokenValue()
};
return(postParam);
}
public async Task CanGetItems_PostMultipleItems()
{
var repository = new InMemoryItemRepository();
var readRepository = new InMemoryItemReadRepository();
repository.EventOccurred += async entity => await new ItemReadModelHandler(readRepository).Handle(entity.NewEvents.ToList <object>());
var itemController =
new ItemController(repository, readRepository)
.BootstrapForTests();
var postNewPotatoItemDto = new PostRequestDto
{
Code = "potato",
Price = 30
};
await itemController.Post(postNewPotatoItemDto);
var postNewLettuceItemDto = new PostRequestDto
{
Code = "lettuce",
Price = 50
};
await itemController.Post(postNewLettuceItemDto);
var potatoResult = await itemController.GetByItemCode("potato");
Assert.Equal((int)HttpStatusCode.OK, potatoResult.StatusCode);
var potatoItemDto = (ItemDto)potatoResult.Value;
Assert.Equal("potato", potatoItemDto.Code);
Assert.Equal(30, potatoItemDto.Price);
var lettuceResult = await itemController.GetByItemCode("lettuce");
Assert.Equal((int)HttpStatusCode.OK, lettuceResult.StatusCode);
var lettuceItemDto = (ItemDto)lettuceResult.Value;
Assert.Equal("lettuce", lettuceItemDto.Code);
Assert.Equal(50, lettuceItemDto.Price);
}
public PostResponseDto Update(int id, PostRequestDto request)
{
var userId = _userService.GetCurrentUserId();
var post = _db.Posts.FirstOrDefault(post => post.Id == id);
if (post == null)
{
throw new ResourceNotFoundException("Post");
}
;
if (post.UserId != userId)
{
throw new ForbiddenActionException();
}
var categories = _db.Categories
.Where(category => request.Categories.Contains(category.Id))
.Select(category => new PostCategory {
Category = category
})
.ToList();
post.Photos.Clear();
post.Title = request.Title;
post.Description = request.Description;
post.Content = request.Content;
post.MainPhoto = request.MainPhoto;
post.Categories = categories;
post.Photos = request.Photos.Select(src => new Photo {
Src = src
}).ToList();
_db.SaveChanges();
_userActivityService.Track($"Updated post({post.Id}): {post.Title}");
return(_mapper.Map <PostResponseDto>(post));
}
public HttpResponseMessage CreatePost(PostRequestDto postRequestDto)
{
var response = new HttpResponseMessage();
try
{
_Uow.Posts.CreatePost(postRequestDto);
response = Request.CreateResponse(HttpStatusCode.OK, "Post created successfully");
return(response);
}
catch (Exception ex)
{
var ErrorResponse = new ErrorResponseDto
{
ExceptionMessage = ex.Message,
InnerExceptionMessage = ex.InnerException == null ? "None" : ex.InnerException.Message
};
response = Request.CreateResponse(HttpStatusCode.BadRequest, ErrorResponse);
return(response);
}
}
public void CreatePost(PostRequestDto postRequestDto)
{
var post = new Post
{
Title = postRequestDto.Title,
Content = postRequestDto.Content,
Likes = postRequestDto.Likes,
Dislikes = postRequestDto.Dislikes,
CategoryId = 5
};
_context.Posts.Add(post);
_context.SaveChanges();
var postId = post.Id;
var imageNameWithoutExtension = Path.GetFileNameWithoutExtension(postRequestDto.ImageFile.FileName);
var imageExtension = Path.GetExtension(postRequestDto.ImageFile.FileName);
var imageName = imageNameWithoutExtension + imageExtension;
var pathToImage = "~/UploadedImages/" + imageName;
var imagePath = Path.Combine(HttpContext.Current.Server.MapPath("~/UploadedImages/"), imageName);
postRequestDto.ImageFile.SaveAs(imagePath);
var image = new Image
{
Name = imageName,
Url = pathToImage,
Extension = imageExtension,
postId = postId
};
_context.Images.Add(image);
_context.SaveChanges();
}
public async Task GetReturnsTheSameItem_PostsTheSameItemTwiceButUsesDataOfTheFirst()
{
var repository = new InMemoryItemRepository();
var readRepository = new InMemoryItemReadRepository();
repository.EventOccurred += async entity => await new ItemReadModelHandler(readRepository).Handle(entity.NewEvents.ToList <object>());
var itemController =
new ItemController(repository, readRepository)
.BootstrapForTests();
var postNewPotatoItemDto = new PostRequestDto
{
Code = "potato",
Price = 30
};
await itemController.Post(postNewPotatoItemDto);
var postNewLettuceItemDto = new PostRequestDto
{
Code = "potato",
Price = 50
};
await itemController.Post(postNewLettuceItemDto);
var potatoResult = await itemController.GetByItemCode("potato");
Assert.Equal((int)HttpStatusCode.OK, potatoResult.StatusCode);
var potatoItemDto = (ItemDto)potatoResult.Value;
Assert.Equal("potato", potatoItemDto.Code);
Assert.Equal(30, potatoItemDto.Price);
}
public KeyValuePair<HttpStatusCode, string> Put(PostRequestDto parameters)
{
try
{
KeyValuePair<HttpStatusCode, string> responseBody;
using (var client = new HttpClient())
{
HttpClientConfig(client, parameters.TokenValue);
using (var putAsync = client.PutAsync(parameters.Url, GetStringContent(parameters.RequestData)))
{
putAsync.Wait();
responseBody = GetResponseContentByStatusCodeAsync(putAsync.Result);
}
}
return responseBody;
}
catch (Exception ex)
{
var errorMessage = $@"Error in: {GetType().FullName}, method : put, put: {parameters.RequestData.Replace(new[] { '}', '{', '\\', '\"' }, string.Empty)}, innerExceptionType: {ex.GetType()}, innerExceptionMessage: {ex.Message}";
throw new RequestHandlerPostException(errorMessage);
}
}
public ActionResult CreatePost(PostRequestDto postRequestDto)
{
_Uow.Posts.CreatePost(postRequestDto);
return(Json("Post created successfully", JsonRequestBehavior.AllowGet));
}
public PostResponseDto Post([FromBody] PostRequestDto request)
{
return(_postService.Create(request));
}
public PostResponseDto Put(int id, [FromBody] PostRequestDto request)
{
return(_postService.Update(id, request));
}
