public Either <string, ReviewView> Update(ReviewView reviewView)
{
try
{
var review = _dbContext.Reviews.Find(reviewView.Id);
if (review == null)
{
return("review not found");
}
review.Title = reviewView.Title;
review.Content = reviewView.Content;
review.ReviewDate = DateTime.Now;
review.Stars = reviewView.Stars;
_dbContext.Reviews.Update(review);
_dbContext.SaveChanges();
return(ReviewMapper.ToView(review));
}
catch (Exception ex)
{
_logger.LogError("can't update review - ", ex);
return("can't update review");
}
}
public void GetById_SeededReview()
{
var review = _reviewRepositorySUT.GetById(Seed.Review1.Id);
Assert.Equal(ReviewMapper.MapToDetailModel(Seed.Review1), review,
ReviewDetailModel.ReviewDetailModelComparer);
}
public override async Task <List <DAL.App.DTO.Review> > AllAsync()
{
return(await RepositoryDbSet
.Include(m => m.ReviewComment)
.ThenInclude(t => t.Translations)
.Include(r => r.ReviewReceiver)
.Include(r => r.ReviewGiver)
.Select(e => ReviewMapper.MapFromDomain(e)).ToListAsync());
}
public void ConvertToModel()
{
var review = DataFixture.BuildReview(Name);
review.TextAnalysis = null;
var model = ReviewMapper.ToModel(ReviewView);
model.Should().BeEquivalentTo(review);
}
public void MapReviewToDTO_ShouldReturnEmptyDTOIfFailed()
{
//Arrange
//Act
var sut = ReviewMapper.MapReviewToDTO(null);
//Assert
Assert.AreEqual(sut.ID, null);
Assert.AreEqual(sut.Description, null);
Assert.AreEqual(sut.Beer, null);
Assert.AreEqual(sut.User, null);
}
public Either <string, ReviewView> Get(long id)
{
try
{
var review = _dbContext.Reviews.Find(id);
return(ReviewMapper.ToView(review));
}
catch (Exception ex)
{
_logger.LogError("can't get review - ", ex);
return("can't get review");
}
}
public void MapDTOToReview_ShouldReturnEmptyCountryIfFailed()
{
//Arrange
//Act
var sut = ReviewMapper.MapDTOToReview(null);
//Assert
Assert.AreEqual(sut.ID, null);
Assert.AreEqual(sut.Beer, null);
Assert.AreEqual(sut.Comments, null);
Assert.AreEqual(sut.User, null);
Assert.AreEqual(sut.CreatedOn, default);
Assert.AreEqual(sut.ModifiedOn, null);
Assert.AreEqual(sut.DeletedOn, null);
Assert.AreEqual(sut.IsDeleted, false);
}
public void NewReview_InsertOrUpdate_ReviewAdded()
{
var review = new ReviewDetailModel()
{
NickName = "Peter99",
Date = new DateTime(2002, 11, 06),
Rating = 95,
TextReview = "Paradny film"
};
review = _reviewRepositorySUT.InsertOrUpdate(review);
using var dbxAssert = _dbContextFactory.CreateDbContext();
var reviewFromDb = dbxAssert.Reviews.Single(i => i.Id == review.Id);
Assert.Equal(review, ReviewMapper.MapToDetailModel(reviewFromDb),
ReviewDetailModel.ReviewDetailModelComparer);
}
public Either <string, ReviewView> Add(ReviewView reviewView)
{
try
{
var review = ReviewMapper.ToModel(reviewView);
_dbContext.Reviews.Add(review);
_dbContext.SaveChanges();
_textAnalysisService.SaveContentAnalysis(review.Content, review.Id);
return(ReviewMapper.ToView(review));
}
catch (Exception ex)
{
_logger.LogError("can't add review - ", ex);
return("can't add review");
}
}
public void UpdateReview(ReviewDto review)
{
if (_repository.AllEntities().Any(x => x.Id == review.ReviewId))
{
if (review.Rating < 0)
{
review.Rating = 0;
}
if (review.Rating > 10)
{
review.Rating = 10;
}
_repository.Update(ReviewMapper.Map(review));
_unitOfWork.SaveChanges();
}
else
{
throw new Exception($"There is no review with the id {review.ReviewId}");
}
}
public void AddNewReview(ReviewDto review)
{
if (!_repository.AllEntities().Any(x => x.UserId == review.UserId && x.ProductId == review.ProductId))
{
if (review.Rating < 0)
{
review.Rating = 0;
}
if (review.Rating > 10)
{
review.Rating = 10;
}
_repository.Add(ReviewMapper.Map(review));
_unitOfWork.SaveChanges();
}
else
{
throw new Exception("User already reviewed the product!");
}
}
public override async Task <Review> FindAsync(params object[] id)
{
var culture = Thread.CurrentThread.CurrentUICulture.Name.Substring(0, 2).ToLower();
var review = await RepositoryDbSet.FindAsync(id);
if (review != null)
{
await RepositoryDbContext.Entry(review)
.Reference(c => c.ReviewComment)
.LoadAsync();
await RepositoryDbContext.Entry(review.ReviewComment)
.Collection(b => b.Translations)
.Query()
.Where(t => t.Culture == culture)
.LoadAsync();
}
return(ReviewMapper.MapFromDomain(review));
}
public void SeededReview_InsertOrUpdate_ReviewUpdated()
{
var review = new ReviewDetailModel()
{
Id = Seed.Review1.Id,
NickName = Seed.Review1.NickName,
Date = Seed.Review1.Date,
Rating = Seed.Review1.Rating,
TextReview = Seed.Review1.TextReview,
};
review.NickName += "updated";
review.TextReview += "updated";
_reviewRepositorySUT.InsertOrUpdate(review);
using var dbxAssert = _dbContextFactory.CreateDbContext();
var reviewFromDb = dbxAssert.Reviews.Single(i => i.Id == review.Id);
Assert.Equal(review, ReviewMapper.MapToDetailModel(reviewFromDb),
ReviewDetailModel.ReviewDetailModelComparer);
}
public async Task <IList <Review> > QueryReview(ReviewFilter filter)
{
var requestIDs = new DataTable();
requestIDs.Columns.Add("Val");
if (filter.RequestIDs?.Any() ?? false)
{
foreach (var id in filter.RequestIDs)
{
requestIDs.Rows.Add(id);
}
}
var param = new DynamicParameters();
param.Add("RequestIDs", requestIDs.AsTableValuedParameter("dbo.BigIntType"));
var mapper = new ReviewMapper();
return((await SqlMapper.QueryAsync(_unitOfWork.Connection,
"QueryReview",
new[]
{
typeof(Review),
typeof(ReviewLineItem)
},
obj =>
{
var review = obj[0] as Review;
var lineItem = obj[1] as ReviewLineItem;
return mapper.Map(review, lineItem);
},
param,
splitOn: "ID,LineItemID",
commandType: CommandType.StoredProcedure,
transaction: _unitOfWork.Transaction)).Distinct().ToList());
}
public override async Task <BLL.App.DTO.Review> FindAsync(params object[] id)
{
return(ReviewMapper.MapFromDAL(await Uow.Reviews.FindAsync(id)));
}
public ReviewOrchestrator(IQaVacancyClient vacancyClient, ReviewMapper mapper)
{
_vacancyClient = vacancyClient;
_mapper = mapper;
}
public ReviewController(ReviewManager manager, ReviewMapper mapper)
{
_manager = manager;
_mapper = mapper;
}
public void GetAll_Single_SeededReview()
{
var review = _reviewRepositorySUT.GetAll().Single(i => i.Id == Seed.Review1.Id);
Assert.Equal(ReviewMapper.MapToListModel(Seed.Review1), review, ReviewListModel.ReviewListModelComparer);
}
public ReviewOrchestrator(IQaVacancyClient vacancyClient, ReviewMapper mapper, IMessaging messaging)
{
_vacancyClient = vacancyClient;
_mapper = mapper;
_messaging = messaging;
}
public void ConvertToView()
{
var view = ReviewMapper.ToView(Review);
view.Should().BeEquivalentTo(ReviewView);
}
