/// <summary>
/// Post book review
/// </summary>
/// <param name="review"></param>
/// <returns></returns>
public async Task <ReviewsDTO> PostBookReview(ReviewsDTO review)
{
try
{
var postReview = new Reviews()
{
BookId = review.BookId,
Email = review.Email,
Name = review.Name,
Rating = review.Rating,
ReviewDate = DateTime.Now,
};
_db.Reviews.Add(postReview);
await _db.SaveChangesAsync();
return(EntityToDTO(postReview));
}
catch (Exception ex)
{
// Log error
throw ex;
}
}
/// <summary>
/// Get reviews by specific user
/// </summary>
/// <param name="ID">Route param that user entered in</param>
public async Task <ReviewsDTO> GetReviews(int ID)
{
var review = await _context.Reviews.FindAsync(ID);
ReviewsDTO rDTO = ConvertToDTO(review);
return(rDTO);
}
public ActionResult Put([FromBody] ReviewsDTO reviewsDto)
{
if (ReviewsDAO.Update(reviewsDto))
{
return(Ok());
}
return(BadRequest());
}
public HttpResponseMessage AddReview(ReviewsDTO reviewsDTO)
{
VolunteerMatchDbContext db = new VolunteerMatchDbContext();
DateTime now = DateTime.Now;
long unixTime = ((DateTimeOffset)now).ToUnixTimeSeconds();
try
{
Review review = new Review
{
fromMemberId = reviewsDTO.fromMemberId,
memberId = reviewsDTO.memberId,
text = reviewsDTO.text,
url = reviewsDTO.url,
stars = reviewsDTO.stars,
date = (int)unixTime
};
db.Reviews.Add(review);
db.SaveChanges();
}
catch (DbEntityValidationException ex)
{
string errors = "";
foreach (DbEntityValidationResult vr in ex.EntityValidationErrors)
{
foreach (DbValidationError er in vr.ValidationErrors)
{
errors += $"PropertyName - {er.PropertyName }, Error {er.ErrorMessage} <br/>";
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (DbUpdateException ex)
{
DbUpdateException e = (DbUpdateException)ex;
string errors = "";
foreach (DbEntityEntry entry in e.Entries)
{
errors += $"Error in entity - {entry.Entity.GetType().Name}, entity state - {entry.State} <br/>";
foreach (string prop in entry.CurrentValues.PropertyNames)
{
errors += $"for column - {prop}, value - {entry.CurrentValues[prop]} <br/>";
}
errors += "---------------";
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
return(Request.CreateResponse(HttpStatusCode.OK, "Review added"));
}
/// <summary>
/// Get all of the reviews
/// </summary>
public async Task <List <ReviewsDTO> > GetAllReviews()
{
List <ReviewsDTO> rDTOList = new List <ReviewsDTO>();
List <Reviews> reviews = await _context.Reviews.ToListAsync();
foreach (var item in reviews)
{
ReviewsDTO rDTO = ConvertToDTO(item);
rDTOList.Add(rDTO);
}
return(rDTOList);
}
//Returns true or false on if review has been created, will be used with response
public bool Create(ReviewsDTO rev)
{
//Description length based on business requirements
//Length must be greater than 2 characters and less than 256
if (rev.ReviewMessage.Length < 2 || rev.ReviewMessage.Length > 256)
{
return(false);
}
var gateway = new ReviewsGateway();
return(gateway.AddReview(rev));
}
/// <summary>
/// Converting DTO object from reviews to DTO
/// </summary>
/// <param name="reviews">Review that is being passed in from database</param>
private ReviewsDTO ConvertToDTO(Reviews reviews)
{
ReviewsDTO rDTO = new ReviewsDTO()
{
Id = reviews.Id,
Description = reviews.Description,
Rate = Convert.ToInt32(reviews.Rate),
Name = reviews.Name,
ActivityID = 0
};
return(rDTO);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Rating,Description,Hidden,ProductId,UserAccountId")] Reviews review)
{
if (id != review.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(review);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReviewExists(review.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ReviewsDTO reviews = new ReviewsDTO
{
Id = review.Id,
Description = review.Description,
Hidden = review.Hidden,
ProductId = review.ProductId,
Rating = review.Rating,
UserAccountId = review.UserAccountId
};
try
{
var response = await _reviews.PushReview(reviews);
}
catch (Exception e)
{
//_logger.LogWarning(e);
}
ViewData["UserAccountId"] = new SelectList(_context.UserAccounts, "Id", "Id", review.UserAccountId);
ViewData["ProductId"] = new SelectList(_context.Products, "Id", "Id", review.ProductId);
return(View(review));
}
public IHttpActionResult CreateReview([FromBody] ReviewsDTO review)
{
ReviewService service = new ReviewService();
bool response = service.Create(review);
if (response)
{
return(Ok("Review has been added"));
}
else
{
return(Content(HttpStatusCode.BadRequest, "Review addition has failed. Invalid Inputs."));
}
}
/// <summary>
/// Getting the reviews using the ID of Activities
/// </summary>
/// <param name="ID">Activities ID</param>
public async Task <List <ReviewsDTO> > GetReviewsById(int ID)
{
var reviews = await _context.ActivitiesReviews.Where(x => x.ActivitiesID == ID)
.ToListAsync();
List <ReviewsDTO> rDTOList = new List <ReviewsDTO>();
foreach (var item in reviews)
{
ReviewsDTO review = await _reviewContext.GetReviews(item.ReviewsID);
rDTOList.Add(review);
}
return(rDTOList);
}
////See if the review id exists (used for testing)
public Boolean ReviewExist(ReviewsDTO obj)
{
int getUserID = (from cred in db.Credentials
where obj.Username == cred.UserName
select cred.UserID).FirstOrDefault();
var foundReviewID = getUserID;
//gets the reviewID, if null will return false
if (foundReviewID > 0)
{
return(true);
}
else
{
return(false);
}
}
//Add Review into the database
public bool AddReview(ReviewsDTO obj)
{
//begins transaction between linq and sql
using (var dbTransaction = db.Database.BeginTransaction())
{
try
{
//Gets userID based off of username based on credentials
int getUserID = (from cred in db.Credentials
where obj.Username == cred.UserName
select cred.UserID).FirstOrDefault();
int getTargetUserID = (from cred in db.Credentials
where obj.TargetUser == cred.UserName
select cred.UserID).FirstOrDefault();
//ReviewID is a key and will be automatically incremented
//creates a new review instance by grabbing object's data from client
Review r = new Review
{
UserID = getTargetUserID,
RevieweeID = getUserID,
Rating = obj.Rating,
ReviewMessage = obj.ReviewMessage,
DateAndTime = obj.DateAndTime,
};
//add the new instance and saves into database
db.Review.Add(r);
db.SaveChanges();
dbTransaction.Commit();
return(true);
}
catch (SqlException)
{
dbTransaction.Rollback();
return(false);
}/*
* catch (DataException)
* {
* dbTransaction.Rollback();
* return false;
* }
*/
}
}
/// <summary>
/// Add activityreview in a instance of review and updating the reviews to the page
/// </summary>
/// <param name="reviewDTO">review from front end</param>
public async Task <ReviewsDTO> CreateReviews(ReviewsDTO reviewDTO)
{
Reviews reviews = new Reviews()
{
Id = reviewDTO.Id,
Name = reviewDTO.Name,
Description = reviewDTO.Description,
Rate = (Rate)reviewDTO.Rate
};
_context.Add(reviews);
await _context.SaveChangesAsync();
await CreateActivityReviews(reviewDTO.ActivityID);
Activities activities = await _context.Activities.FindAsync(reviewDTO.ActivityID);
var upvote = await _context.ActivitiesReviews.Where(x => x.ActivitiesID == reviewDTO.ActivityID)
.ToListAsync();
double count = 0;
foreach (var vote in upvote)
{
Reviews reviews1 = await _context.Reviews.FindAsync(vote.ReviewsID);
if (reviews1.Rate == (Rate)0)
{
count++;
}
}
activities.Rating = (count / upvote.Count) * 5;
_context.Update(activities);
await _context.SaveChangesAsync();
return(reviewDTO);
}
public ReviewsDTO Post([FromBody] ReviewsDTO reviewsDto)
{
return(ReviewsDAO.Post(reviewsDto));
}
public async Task <ActionResult <Reviews> > PostReviews(ReviewsDTO reviews)
{
await _context.CreateReviews(reviews);
return(CreatedAtAction("GetReviews", new { id = reviews.Id }, reviews));
}
