public bool CreateReview(ReviewCreate model)
{
CreateReviewCallCount++;
return(CreateReviewReturnValue);
}
public async Task <Review> UpsertAsync(ReviewCreate reviewCreate, int applicationUserId)
{
using (var dataTable = new DataTable())
{
dataTable.Columns.Add("ReviewId", typeof(int));
dataTable.Columns.Add("Title", typeof(string));
dataTable.Columns.Add("Content", typeof(string));
dataTable.Columns.Add("PhotoId", typeof(int));
dataTable.Rows.Add(reviewCreate.ReviewId, reviewCreate.Title, reviewCreate.Content, reviewCreate.PhotoId);
int?newReviewId;
using (var connection = new SqlConnection(_config.GetConnectionString("DefaultConnection")))
{
await connection.OpenAsync();
newReviewId = await connection.ExecuteScalarAsync <int?>(
"Review_Upsert",
new
{
Review = dataTable.AsTableValuedParameter("dbo.ReviewType"),
ApplicationUserId = applicationUserId
},
commandType : CommandType.StoredProcedure);
}
newReviewId = newReviewId ?? reviewCreate.ReviewId;
Review review = await GetAsync(newReviewId.Value);
return(review);
}
}
public async Task <ActionResult> Create(ReviewCreate note)
{
if (!ModelState.IsValid)
{
ViewBag.RestaurantId = await GetReviewAsync();
ViewBag.CustomerId = await GetCustomerAsync();
return(View(note));
}
var service = CreateReviewService();
if (await service.CreateReviewAsync(note))
{
TempData["SaveResult"] = "Review was created.";
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Review could not be created.");
ViewBag.RestaurantId = await GetRestaurantAsync();
ViewBag.CustomerId = await GetCustomerAsync();
return(View(note));
}
public async Task <IActionResult> CreateReview([FromBody] ReviewCreate creationModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
var review = await _reviewData.CreateReview(creationModel);
var returnModel = Mapper.Map <ReviewReturnModel>(review);
var links = CreateLinksForReview(returnModel.Id, null);
var returnModelWithLinks = returnModel.ShapeData(null)
as IDictionary <string, object>;
returnModelWithLinks.Add("links", links);
return(CreatedAtRoute("GetReview", new { id = returnModel.Id }, returnModelWithLinks));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <Review> CreateReview(ReviewCreate creationModel)
{
Review review;
Movie movie = await _dbContext.Movies
.FirstOrDefaultAsync(m => m.Title.ToLower() == creationModel.Movie.Title.ToLower() &&
m.ReleaseYear == creationModel.Movie.ReleaseYear);
Reviewer reviewer = await _dbContext.Reviewers
.FirstOrDefaultAsync(r => r.Username == creationModel.ReviewerName);
// Create review model for an existing movie
if (movie != null)
{
review = new Review
{
Title = creationModel.Title,
MovieId = movie.Id,
Body = creationModel.Body,
Rating = creationModel.Rating,
SubmitTime = creationModel.SubmitTime,
ReviewerId = reviewer.Id
};
// If movie exists, update it's AverageRating
await UpdateAverageRating(movie.Id, creationModel.Rating);
}
// Create Review model for a new movie
else
{
review = new Review
{
Title = creationModel.Title,
Movie = new Movie
{
Title = creationModel.Movie.Title,
Author = creationModel.Movie.Author,
AverageRating = creationModel.Rating,
ImagePath = await _posterData.GetMoviePoster(creationModel.Movie.ReleaseYear,
creationModel.Movie.Title),
ReleaseYear = creationModel.Movie.ReleaseYear
},
Body = creationModel.Body,
Rating = creationModel.Rating,
SubmitTime = creationModel.SubmitTime,
ReviewerId = reviewer.Id
};
}
await _dbContext.AddAsync(review);
reviewer.NumberOfReviewsSubmitted++;
_dbContext.Reviewers.Update(reviewer);
await _dbContext.SaveChangesAsync();
return(review);
}
public ActionResult Create(int id)
{
var model = new ReviewCreate
{
MovieID = id,
OwnerID = Guid.Parse(User.Identity.GetUserId())
};
return(View(model));
}
public ActionResult Create(int id)
{
var model = new ReviewCreate
{
ProductId = id,
UserId = Guid.Parse(User.Identity.GetUserId())
};
return(View(model));
}
public IActionResult Create([FromBody] ReviewCreate review)
{
var model = _mapper.Map <Review>(review);
var createdReview = ReviewRepository.Create(model);
_unitOfWork.SaveChanges();
return(Created("", _mapper.Map <ReviewView>(createdReview)));
}
public ActionResult <ReviewCreate> CreateReview(ReviewCreate reviewCreate)
{
var reviewModel = _mapper.Map <Review>(reviewCreate);
_data.CreateReview(reviewModel);
_data.SaveChanges();
var reviewRead = _mapper.Map <Review>(reviewModel);
return(CreatedAtRoute(nameof(GetReviewById), new { ReviewId = reviewRead.ReviewId }, reviewRead));
}
public ActionResult CreateWithDefault(int gameId)
{
var reviewCreate = new ReviewCreate();
reviewCreate.GameId = gameId;
var gameService = CreateGameService();
var gameID = gameService.GetGames();
var game = new SelectList(gameID.OrderBy(g => g.Title).ToList(), "GameID", "Title");
ViewBag.Game = game;
return(View("Create", reviewCreate));
}
public bool CreateReview(ReviewCreate model)
{
Review review = new Review()
{
UserId = _userId,
ReviewText = model.ReviewText,
Score = model.Score,
CreatedUtc = DateTimeOffset.Now,
MovieId = model.MovieId
};
_context.Reviews.Add(review);
return(_context.SaveChanges() == 1);
}
public IHttpActionResult PostReview(ReviewCreate model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ReviewService service = CreateReviewService();
if (!service.CreateReview(model))
{
return(InternalServerError());
}
return(Ok());
}
public bool CreateMovie(ReviewCreate model)
{
var entity =
new Review()
{
Summary = model.Summary,
MovieId = model.MovieId,
};
using (var context = new ApplicationDbContext())
{
context.Reviews.Add(entity);
return(context.SaveChanges() == 1);
}
}
public IHttpActionResult Post(ReviewCreate review)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = CreateReviewService();
if (!service.CreateReview(review))
{
return(InternalServerError());
}
return(Ok("Your review has been successfully created!"));
}
public bool CreateReview(ReviewCreate model, int gameID)
{
var entity = new Review
{
UserID = _userID,
CreatorDisplayName = GetDisplayName(_userID),
GameID = gameID,
//GameID = model.GameID,
ReviewRating = model.ReviewRating,
ReviewDescription = model.ReviewDescription
};
_db.Reviews.Add(entity);
return(_db.SaveChanges() == 1);
}
public IHttpActionResult Post(ReviewCreate model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var reviewService = CreateReviewService(model.ProductId);
if (!reviewService.Create(model))
{
return(InternalServerError());
}
return(Ok());
}
public bool CreateReview(ReviewCreate model)
{
var entity =
new Review()
{
Reviews = model.Reviews,
CustomerId = model.CustomerId,
RestaurantId = model.RestaurantId
};
using (var ctx = new ApplicationDbContext())
{
ctx.Review.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public ActionResult CreateMusicReview(ReviewCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var service = CreateReviewService();
if (service.CreateReview(model))
{
TempData["SaveResult"] = "Your Review was created";
return(RedirectToAction("Index"));
}
;
ModelState.AddModelError("", "Review could not be created");
return(View(model));
}
public void MapFromCreate()
{
var newReview = new ReviewCreate
{
AuthorName = "Rodolpho C. Alves",
ReviewText = "Lorem ipsum dolor sit amet",
Score = 10d,
SubjectId = Guid.NewGuid().ToString()
};
var review = _mapper.Map <Review>(newReview);
review.Should()
.NotBeNull(because: "an object is always expected").And
.BeOfType <Review>(because: "it should be a Review").And
.BeEquivalentTo(newReview, because: "it should have the same properties as the original object");
}
public bool CreateReview(ReviewCreate model)
{
var entity = new Review()
{
Stars = model.Stars,
Title = model.Title,
Text = model.Text,
OwnerId = _userId,
GymId = model.GymId
};
using (var ctx = new ApplicationDbContext())
{
ctx.Reviews.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
//method to create a Review
public bool CreateBrewery(ReviewCreate model)
{
var entity = new Review()
{
BeerName = model.BeerName,
Brewery = model.Brewery,
ABV = model.ABV,
Rating = model.Rating,
Description = model.Description
};
using (var ctx = new ReviewDbContext())
{
ctx.Reviews.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public bool CreateReview(ReviewCreate model)
{
var entity = new Review()
{
OwnerID = _userId,
MovieID = _movieID,
Reviews = model.YourReview,
CreatedUtc = DateTimeOffset.Now,
UserName = "******"
};
using (var ctx = new ApplicationDbContext())
{
ctx.MovieReviews.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public bool CreateReview(ReviewCreate review)
{
var entity =
new Review()
{
OwnerId = _userId,
Text = review.Text,
Rating = review.Rating,
DateOfReview = DateTimeOffset.Now
};
using (var ctx = new ApplicationDbContext())
{
ctx.Reviews.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public bool CreateReview(ReviewCreate model)
{
var entity =
new Review()
{
VenueID = model.VenueID,
VenueRating = model.VenueRating,
Comments = model.Comments,
ApplicationUserID = _userID,
};
using (var ctx = new ApplicationDbContext())
{
ctx.Reviews.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public async Task <bool> CreateReviewAsync(ReviewCreate model)
{
var entity =
new Review()
{
// OwnerID = _userId,
Reviews = model.Reviews,
CustomerId = model.CustomerId,
RestaurantId = model.RestaurantId
};
using (var ctx = new ApplicationDbContext())
{
ctx.Review.Add(entity);
return(await ctx.SaveChangesAsync() == 1);
}
}
public bool CreateReview(ReviewCreate model)
{
var reviewToCreate =
new Review()
{
UserId = _userId,
BookId = model.BookId,
Title = model.Title,
Content = model.Content,
CreatedUtc = DateTimeOffset.Now
};
using (var ctx = new ApplicationDbContext())
{
ctx.Reviews.Add(reviewToCreate);
return(ctx.SaveChanges() == 1);
}
}
public async Task <ActionResult <Review> > Create(ReviewCreate reviewCreate)
{
int applicationUserId = int.Parse(User.Claims.First(i => i.Type == JwtRegisteredClaimNames.NameId).Value);
if (reviewCreate.PhotoId.HasValue)
{
var photo = await _photoRepository.GetAsync(reviewCreate.PhotoId.Value);
if (photo.ApplicationUserId != applicationUserId)
{
return(BadRequest("You did not upload the photo."));
}
}
var review = await _reviewRepository.UpsertAsync(reviewCreate, applicationUserId);
return(Ok(review));
}
public ActionResult Create(ReviewCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var service = CreateReviewService();
if (service.CreateReview(model))
{
TempData["SaveResult"] = "Your Review was created.";
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Ash, you cannot use this item at this time.");
return(View(model));
}
public bool CreateReview(ReviewCreate model)
{
var entity =
new Review()
{
OwnerId = _userId,
//FirstName = model.FirstName,
//LastName = model.LastName,
Description = model.Description,
DriverId = model.DriverId
};
using (var ctx = new ApplicationDbContext())
{
ctx.Reviews.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
public ActionResult Create(ReviewCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (_reviewService.Value.CreateReview(model))
{
TempData["SaveResult"] = "Your review was created, thank you.";
return(RedirectToAction("Index"));
}
;
ModelState.AddModelError("", "Review could not be created.");
return(View(model));
}
