public async Task <bool> CreateMovieAsync(CreateMovieInputModel input)
{
if (!await dbContext.Genres.AnyAsync(genre => genre.Name == input.Genre))
{
return(false);
}
if (!await dbContext.Artists.AnyAsync(artist => artist.FullName == input.Director))
{
return(false);
}
if (await dbContext.Movies.AnyAsync(movie => movie.Name == input.Name))
{
return(false);
}
var genreFromDb = await dbContext.Genres.SingleOrDefaultAsync(g => g.Name == input.Genre);
var directorFromDb = await dbContext.Artists.SingleOrDefaultAsync(a => a.FullName == input.Director);
var movieForDb = mapper.Map <CreateMovieInputModel, Movie>(input);
movieForDb.Genre = genreFromDb;
movieForDb.Director = directorFromDb;
await dbContext.Movies.AddAsync(movieForDb);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task <bool> CreateTVShowAsync(CreateTVShowInputModel input)
{
if (!await dbContext.Genres.AnyAsync(genre => genre.Name == input.Genre))
{
return(false);
}
if (!await dbContext.Artists.AnyAsync(artist => artist.FullName == input.Creator))
{
return(false);
}
if (await dbContext.TVShows.AnyAsync(tvShow => tvShow.Name == input.Name))
{
return(false);
}
var genreFromDb = await dbContext.Genres.SingleOrDefaultAsync(g => g.Name == input.Genre);
var creatorFromDb = await dbContext.Artists.SingleOrDefaultAsync(a => a.FullName == input.Creator);
var tvShowForDb = mapper.Map <CreateTVShowInputModel, TVShow>(input);
tvShowForDb.Genre = genreFromDb;
tvShowForDb.Creator = creatorFromDb;
await dbContext.TVShows.AddAsync(tvShowForDb);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task AddMovieToUserWatchlistAsync(string userId, string movieId)
{
var movieUserForDb = new MovieUser
{
MovieId = movieId,
UserId = userId,
};
await dbContext.MovieUsers.AddAsync(movieUserForDb);
await dbContext.SaveChangesAsync();
}
public async Task IsValidMovieOrTVShowIdShouldReturnCorrectResult()
{
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var tvShow1 = new TVShow
{
Name = "tvShow1",
Description = "description2",
Genre = new Genre {
Name = "genre2"
},
Creator = artist1,
CoverImageLink = "cover2",
TrailerLink = "trailer2",
};
await dbContext.Movies.AddAsync(movie1);
await dbContext.TVShows.AddAsync(tvShow1);
await dbContext.SaveChangesAsync();
var movieId = movie1.Id;
var tvShowId = tvShow1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
var movieResult = await watchlistService.IsValidMovieOrTVShowIdAsync(movieId);
var seasonResult = await watchlistService.IsValidMovieOrTVShowIdAsync(tvShowId);
var invalid = await watchlistService.IsValidMovieOrTVShowIdAsync("invalidId");
Assert.True(movieResult);
Assert.True(seasonResult);
Assert.False(invalid);
}
public async Task <bool> CreateAnnouncementAsync(CreateAnnouncementInputModel input)
{
if (await dbContext.Announcements.AnyAsync(announcement => announcement.Title == input.Title && announcement.Content == input.Content))
{
return(false);
}
var announcementFromDb = mapper.Map <CreateAnnouncementInputModel, Announcement>(input);
await dbContext.Announcements.AddAsync(announcementFromDb);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task <bool> CreateArtistAsync(CreateArtistInputModel input)
{
if (await dbContext.Artists.AnyAsync(artist => artist.FullName == input.FullName && artist.Biography == input.Biography && artist.BirthDate == artist.BirthDate))
{
return(false);
}
var artistForDb = mapper.Map <CreateArtistInputModel, Artist>(input);
await dbContext.Artists.AddAsync(artistForDb);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task GetUserAvatarLinkShouldReturnDefaultImageIfIdIsInvalid()
{
var user = new MovieDatabaseUser
{
AvatarLink = "avatar",
Email = "*****@*****.**",
UserName = "******",
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var avatarService = new AvatarService(dbContext);
var actualResult = await avatarService.GetUserAvatarLink("invalidId");
Assert.True(actualResult == GlobalConstants.avatarLinkPrefix + "no_avatar.jpg");
}
public async Task GetUserIdFromUsrnameShouldReturnNullIfInputIsInvalid()
{
var user = new MovieDatabaseUser
{
AvatarLink = "avatar",
Email = "*****@*****.**",
UserName = "******",
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var userService = new UserService(dbContext, mockUserManager.Object);
var actualResult = await userService.GetUserIdFromUserNameAsync("invalid");
Assert.True(actualResult == null);
}
public async Task GetAllGenreNamesShouldReturnGenresProperly()
{
await dbContext.Genres.AddRangeAsync(new List <Genre>
{
new Genre {
Name = "genre1"
},
new Genre {
Name = "genre2"
},
new Genre {
Name = "genre3"
},
});
await dbContext.SaveChangesAsync();
var expectedResult = new List <GenreAllViewModel>
{
new GenreAllViewModel {
Name = "genre1"
},
new GenreAllViewModel {
Name = "genre2"
},
new GenreAllViewModel {
Name = "genre3"
},
};
var genreService = new GenreService(dbContext, mapper);
var actualResult = await genreService.GetAllGenreNamesAsync();
Assert.True(actualResult.Count() == 3);
Assert.True(actualResult[0].Name == "genre1");
Assert.True(actualResult[1].Name == "genre2");
Assert.True(actualResult[2].Name == "genre3");
}
public async Task <bool> CreateGenreAsync(CreateGenreInputModel input)
{
if (await dbContext.Genres.AnyAsync(genre => genre.Name == input.Name))
{
return(false);
}
;
var genreForDb = mapper.Map <CreateGenreInputModel, Genre>(input);
await dbContext.Genres.AddAsync(genreForDb);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task ChangeUserAvatarAsync(string userId, IFormFile avatar)
{
var user = await dbContext.Users.FindAsync(userId);
if (avatar != null && avatar.Length > 0 && avatar.Length < ValidationConstants.userAvatarMaximumFileSizeInBytes)
{
var fileName = user.UserName + GlobalConstants.imageFileSuffix;
var filePath = Path.Combine(Directory.GetCurrentDirectory(), GlobalConstants.userAvatarsDirectory, fileName);
using (var fileSrteam = new FileStream(filePath, FileMode.Create))
{
await avatar.CopyToAsync(fileSrteam);
}
user.AvatarLink = GlobalConstants.avatarLinkPrefix + fileName;
await dbContext.SaveChangesAsync();
}
}
public async Task <bool> CreateMovieReviewAsync(string userId, CreateReviewInputModel input)
{
if (await dbContext.MovieReviews.AnyAsync(movieReview => movieReview.MovieId == input.Id && movieReview.UserId == userId))
{
return(false);
}
var movieReviewForDb = mapper.Map <CreateReviewInputModel, MovieReview>(input);
movieReviewForDb.UserId = userId;
await dbContext.MovieReviews.AddAsync(movieReviewForDb);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task GetAllArtistsShouldReturnAllArtistsProperly()
{
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "something",
Length = 150,
Genre = new Genre {
Name = "Crime"
},
CoverImageLink = "image",
TrailerLink = "trailer",
Director = artist1,
};
var artist2 = new Artist
{
FullName = "name2",
Biography = "biography2",
BirthDate = DateTime.Parse("24 July 2019"),
PhotoLink = "photo2"
};
await dbContext.Artists.AddAsync(artist1);
await dbContext.Movies.AddAsync(movie);
await dbContext.Artists.AddAsync(artist2);
await dbContext.SaveChangesAsync();
var expectedResult = new List <ArtistAllViewModel>()
{
new ArtistAllViewModel
{
FullName = "name1",
Biography = "biography1....",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
CareerProjects = 1,
},
new ArtistAllViewModel
{
FullName = "name2",
Biography = "biography2....",
BirthDate = DateTime.Parse("24 July 2019"),
PhotoLink = "photo2",
CareerProjects = 0,
}
};
var artistService = new ArtistService(dbContext, mapper);
var actualResult = await artistService.GetAllArtistsAsync();
Assert.True(actualResult.Count() == 2);
for (int i = 0; i < expectedResult.Count(); i++)
{
Assert.Equal(expectedResult[i].FullName, actualResult[i].FullName);
Assert.Equal(expectedResult[i].Biography, actualResult[i].Biography);
Assert.Equal(expectedResult[i].BirthDate, actualResult[i].BirthDate);
Assert.Equal(expectedResult[i].PhotoLink, actualResult[i].PhotoLink);
}
}
public async Task GetAllAnnouncementsShouldReturnAllAnnouncementsProperly()
{
var announcement1 = new Announcement
{
Creator = "creator1",
Title = "title1",
Content = "content1",
ImageLink = "image1",
Date = DateTime.Parse("24 July 2019"),
OfficialArticleLink = "article1"
};
var announcement2 = new Announcement
{
Creator = "creator2",
Title = "title2",
Content = "content2",
ImageLink = "image2",
Date = DateTime.Parse("25 July 2019"),
OfficialArticleLink = "article2"
};
await dbContext.Announcements.AddAsync(announcement1);
await dbContext.Announcements.AddAsync(announcement2);
await dbContext.SaveChangesAsync();
var expectedResult = new List <AnnouncementViewModel>()
{
new AnnouncementViewModel
{
Creator = "creator1",
Title = "title1",
Content = "content1",
ImageLink = "image1",
Date = DateTime.Parse("24 July 2019"),
OfficialArticleLink = "article1"
},
new AnnouncementViewModel
{
Creator = "creator2",
Title = "title2",
Content = "content2",
ImageLink = "image2",
Date = DateTime.Parse("25 July 2019"),
OfficialArticleLink = "article2"
}
};
var announcementService = new AnnouncementService(dbContext, mapper);
var actualResult = await announcementService.GetAllAnnouncementsAsync();
for (int i = 0; i < expectedResult.Count(); i++)
{
Assert.Equal(expectedResult[i].Creator, actualResult[i].Creator);
Assert.Equal(expectedResult[i].Title, actualResult[i].Title);
Assert.Equal(expectedResult[i].Content, actualResult[i].Content);
Assert.Equal(expectedResult[i].ImageLink, actualResult[i].ImageLink);
Assert.Equal(expectedResult[i].Date, actualResult[i].Date);
Assert.Equal(expectedResult[i].OfficialArticleLink, actualResult[i].OfficialArticleLink);
}
}
public async Task IsValidMovieOrSeasonIdShouldReturnCorrectResult()
{
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var season1 = new Season
{
SeasonNumber = 1,
Episodes = 5,
ReleaseDate = DateTime.UtcNow,
LengthPerEpisode = 35,
};
await dbContext.Movies.AddAsync(movie1);
await dbContext.Seasons.AddAsync(season1);
await dbContext.SaveChangesAsync();
var movieId = movie1.Id;
var seasonId = season1.Id;
var reviewService = new ReviewService(dbContext, mapper);
var movieResult = await reviewService.IsValidMovieOrSeasonIdAsync(movieId);
var seasonResult = await reviewService.IsValidMovieOrSeasonIdAsync(seasonId);
var invalid = await reviewService.IsValidMovieOrSeasonIdAsync("invalidId");
Assert.True(movieResult);
Assert.True(seasonResult);
Assert.False(invalid);
}
public async Task GetAllMoviesShouldReturnAllMoviesProperly()
{
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var movie2 = new Movie
{
Name = "movie2",
ReleaseDate = DateTime.Parse("25 July 2019"),
Description = "description2",
Length = 170,
Genre = new Genre {
Name = "genre2"
},
Director = artist1,
CoverImageLink = "cover2",
TrailerLink = "trailer2",
};
await dbContext.Artists.AddAsync(artist1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.Movies.AddAsync(movie2);
await dbContext.SaveChangesAsync();
watchlistService.Setup(w => w.MovieIsInUserWatchlistAsync("", ""))
.ReturnsAsync(false);
var movieService = new MovieService(dbContext, reviewService.Object, watchlistService.Object, mapper);
var expectedResult = new List <MovieAllViewModel>
{
new MovieAllViewModel
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Genre = "genre1",
CoverImageLink = "cover1",
Rating = 0,
TotalReviews = 0,
Watchlisted = false,
},
new MovieAllViewModel
{
Name = "movie2",
ReleaseDate = DateTime.Parse("25 July 2019"),
Genre = "genre2",
CoverImageLink = "cover2",
Rating = 0,
TotalReviews = 0,
Watchlisted = false,
}
};
var actualResult = await movieService.GetAllMoviesAsync();
Assert.True(actualResult.Count() == 2);
Assert.True(expectedResult[0].Name == actualResult[0].Name);
Assert.True(expectedResult[0].ReleaseDate == actualResult[0].ReleaseDate);
Assert.True(expectedResult[0].Genre == actualResult[0].Genre);
Assert.True(expectedResult[0].CoverImageLink == actualResult[0].CoverImageLink);
Assert.True(expectedResult[0].Rating == actualResult[0].Rating);
Assert.True(expectedResult[0].TotalReviews == actualResult[0].TotalReviews);
Assert.True(expectedResult[0].Watchlisted == actualResult[0].Watchlisted);
Assert.True(expectedResult[1].Name == actualResult[1].Name);
Assert.True(expectedResult[1].ReleaseDate == actualResult[1].ReleaseDate);
Assert.True(expectedResult[1].Genre == actualResult[1].Genre);
Assert.True(expectedResult[1].CoverImageLink == actualResult[1].CoverImageLink);
Assert.True(expectedResult[1].Rating == actualResult[1].Rating);
Assert.True(expectedResult[1].TotalReviews == actualResult[1].TotalReviews);
Assert.True(expectedResult[1].Watchlisted == actualResult[1].Watchlisted);
}
