public bool AddUser(User newUser)
{
try
{
using (var db = new MovieReviewContext())
{
var exisitingUser = db.User.FirstOrDefault(u => u.Email == newUser.Email || u.UserName == newUser.UserName);
if (exisitingUser == null)
{
var user = new UserDTO();
user.UserId = Guid.NewGuid();
user.Email = newUser.Email;
user.UserName = newUser.UserName;
db.User.Add(user);
db.SaveChanges();
return(true);
}
else
{
return(false);
}
}
} catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public IList <ReviewDTO> GetTopMovies(DateTime date, double range)
{
using (var db = new MovieReviewContext())
{
date = date.AddDays(-range);
IList <ReviewDTO> topMovies = new List <ReviewDTO>();
var reviews = db.Review.Where(r => r.Date.Date >= date.Date).GroupBy(r => r.MovieId).ToList();
foreach (var group in reviews)
{
ReviewDTO rdto = new ReviewDTO();
double scoreSum = 0;
foreach (var review in group)
{
scoreSum += review.Score;
rdto.MovieId = review.MovieId;
}
rdto.Score = scoreSum / group.Count();
topMovies.Add(rdto);
}
return(topMovies);
}
}
public IList <ReviewDTO> GetReviewsbByDateRange(int range)
{
var reviews = new List <ReviewDTO>();
var date = DateTime.Now.AddDays(-range);
using (var db = new MovieReviewContext())
{
var reviewsSearch = db.Review.Where(r => r.Date >= date).OrderByDescending(r => r.Date);
foreach (Review review in reviewsSearch)
{
var reviewDTO = new ReviewDTO();
reviewDTO.Comment = review.Comment;
reviewDTO.Score = review.Score;
reviewDTO.UserName = db.User.Where(u => u.UserId == review.UserId).FirstOrDefault().UserName;
reviewDTO.MovieId = review.MovieId;
reviewDTO.Date = review.Date;
reviewDTO.ReviewId = review.ReviewId;
reviews.Add(reviewDTO);
}
return(reviews);
}
}
public ActorValidator(MovieReviewContext context)
{
RuleFor(x => x.FirstName)
.NotEmpty()
.WithMessage("First name is required");
RuleFor(x => x.LastName)
.NotEmpty()
.WithMessage("Last name is required");
}
public MovieValidator(MovieReviewContext context)
{
RuleFor(x => x.Title)
.NotEmpty()
.WithMessage("Title is required");
RuleFor(x => x.Duration)
.GreaterThan(0)
.WithMessage("Duration must be longer than 0 minutes");
RuleFor(x => x.Year)
.GreaterThan(1887)
.WithMessage("First movie was filmed in 1888, not before that");
}
public UserDTO GetUser(string username)
{
try
{
using (var db = new MovieReviewContext())
{
return(db.User.FirstOrDefault(u => u.UserName == username));
}
} catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ReviewValidator(MovieReviewContext context)
{
RuleFor(x => x.Title)
.NotEmpty()
.WithMessage("Title is required");
RuleFor(x => x.Text)
.NotEmpty()
.MaximumLength(300)
.WithMessage("Please use up to 300 characters");
RuleFor(x => x.MovieRating)
.InclusiveBetween(1, 5)
.WithMessage("Rate between 1 and 5");
RuleFor(x => x.MovieId)
.Must(x => context.Movies.Any(m => m.Id == x))
.WithMessage("No such movie in the database");
}
public bool AddReview(Review review)
{
try
{
using (var db = new MovieReviewContext())
{
review.ReviewId = Guid.NewGuid();
review.Date = DateTime.Now;
db.Review.Add((review));
db.SaveChanges();
return(true);
}
} catch
{
return(false);
}
}
public bool DeleteReview(Guid reviewId)
{
try
{
using (var db = new MovieReviewContext())
{
Review deleteReview = db.Review.Where(r => r.ReviewId == reviewId).FirstOrDefault();
db.Review.Remove(deleteReview);
db.SaveChanges();
return(true);
}
}
catch
{
return(false);
}
}
public UpdateUserValidator(MovieReviewContext context)
{
RuleFor(x => x.FirstName)
.NotEmpty();
RuleFor(x => x.LastName)
.NotEmpty();
RuleFor(x => x.Username)
.NotEmpty()
.MinimumLength(4)
.Must((dto, username) => !context.Users.Any(user => user.Username == username && user.Id != dto.Id))
.WithMessage("Username is already taken.");
RuleFor(x => x.Email)
.NotEmpty()
.EmailAddress()
.Must((dto, email) => !context.Users.Any(user => user.Email == email && user.Id != dto.Id))
.WithMessage("This email is already taken.");
RuleFor(x => x.Password)
.NotEmpty()
.MinimumLength(8);
}
public double GetMovieScore(int movieId)
{
using (var db = new MovieReviewContext())
{
var reviewSearch = db.Review.Where(r => r.MovieId == movieId);
double score = 0;
foreach (Review review in reviewSearch)
{
score += review.Score;
}
if (reviewSearch.Count() == 0)
{
return(-1);
}
else
{
score /= reviewSearch.Count();
return(score);
}
}
}
public AddUserValidator(MovieReviewContext context)
{
RuleFor(x => x.FirstName)
.NotEmpty()
.WithMessage("First name is required");
RuleFor(x => x.LastName)
.NotEmpty()
.WithMessage("Last name is required");
RuleFor(x => x.Username)
.NotEmpty()
.WithMessage("Username is required")
.MinimumLength(4)
.WithMessage("Username must be at least 4 characters long")
.Must(x => !context.Users.Any(user => user.Username == x))
.WithMessage("Username is already taken.");
RuleFor(x => x.Email)
.NotEmpty()
.EmailAddress()
.Must(x => !context.Users.Any(user => user.Email == x))
.WithMessage("This email is already taken.");
RuleFor(x => x.Password)
.NotEmpty()
.MinimumLength(8);
}
public IList <ReviewDTO> GetReviews(int movieId)
{
var reviews = new List <ReviewDTO>();
using (var db = new MovieReviewContext())
{
var reviewsSearch = db.Review.Where(r => r.MovieId == movieId).OrderBy(r => r.Date);
foreach (Review review in reviewsSearch)
{
var reviewDTO = new ReviewDTO();
reviewDTO.Comment = review.Comment;
reviewDTO.Score = review.Score;
reviewDTO.UserName = db.User.Where(u => u.UserId == review.UserId).FirstOrDefault().UserName;
reviewDTO.Date = review.Date;
reviewDTO.ReviewId = review.ReviewId;
reviews.Add(reviewDTO);
}
return(reviews);
}
}
public TestController(MovieReviewContext context)
{
this.context = context;
}
public EfAddActor(MovieReviewContext context, IMapper mapper, ActorValidator validator)
{
this.context = context;
this.mapper = mapper;
this.validator = validator;
}
public EfDeleteReview(MovieReviewContext context)
{
this.context = context;
}
public EfGetUsersQuery(MovieReviewContext context, IMapper mapper)
{
_context = context;
this.mapper = mapper;
}
public EfUpdateUser(MovieReviewContext context, IMapper mapper, UpdateUserValidator validator)
{
this.context = context;
this.mapper = mapper;
this.validator = validator;
}
public EfGetOneMovieQuery(MovieReviewContext context, IMapper mapper)
{
this.context = context;
this.mapper = mapper;
}
public JwtManager(MovieReviewContext context, TokenValidator validator)
{
_context = context;
_validator = validator;
}
public EfAddGenre(MovieReviewContext context, IMapper mapper, GenreValidator validator)
{
this.context = context;
this.mapper = mapper;
this.validator = validator;
}
public GenreValidator(MovieReviewContext context)
{
RuleFor(x => x.Name)
.NotEmpty()
.WithMessage("Genre name is required");
}
