public async Task GetAsync_GivenMultipleExistingAnimeOneOfWhichWithId_ShouldReturnResult() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); var anime1 = new AnimeBuilder().WithMalId(1).Build(); var anime2 = new AnimeBuilder().WithMalId(2).Build(); var anime3 = new AnimeBuilder().WithMalId(3).Build(); var anime4 = new AnimeBuilder().WithMalId(4).Build(); var anime5 = new AnimeBuilder().WithMalId(5).Build(); await dbContext.Animes.AddAsync(anime1); await dbContext.Animes.AddAsync(anime2); await dbContext.Animes.AddAsync(anime3); await dbContext.Animes.AddAsync(anime4); await dbContext.Animes.AddAsync(anime5); await dbContext.SaveChangesAsync(); // When var result = await repository.GetAsync(3); // Then result.Should().NotBeNull(); result.MalId.Should().Be(3); }
public async Task GetOrderedPageByPopularityAsync_GivenMultipleWithDifferentPopularityWithPagesize_ShouldReturnOnlyOnePageByPopularity() { // Given const int pageSize = 2; var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); var anime1 = new AnimeBuilder().WithTitle("Test1").WithPopularity(10).Build(); var anime2 = new AnimeBuilder().WithTitle("Test2").WithPopularity(50).Build(); var anime3 = new AnimeBuilder().WithTitle("Test3").WithPopularity(30).Build(); await dbContext.Animes.AddAsync(anime1); await dbContext.Animes.AddAsync(anime2); await dbContext.Animes.AddAsync(anime3); await dbContext.SaveChangesAsync(); // When var result = await repository.GetOrderedPageByPopularityAsync(x => true, 0, pageSize); // Then// Then using (new AssertionScope()) { result.TotalCount.Should().Be(3); result.Results.Should().HaveCount(2); result.PageSize.Should().Be(pageSize); result.Results.First().Title.Should().Be("Test2"); result.Results.First().Popularity.Should().Be(50); result.Results.Last().Title.Should().Be("Test3"); result.Results.Last().Popularity.Should().Be(30); } }
public async Task UpdateAsync_GivenExistingAnime_ShouldUpdate() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); var anime = new AnimeBuilder().WithTitle("Test").Build(); await dbContext.Animes.AddAsync(anime); await dbContext.SaveChangesAsync(); anime.Title = "Updated"; // When await repository.UpdateAsync(anime); // Then var allAnimes = await dbContext.Animes.ToListAsync(); using (new AssertionScope()) { var updateAnime = allAnimes.SingleOrDefault(); updateAnime.Should().NotBeNull(); updateAnime.Title.Should().Be("Updated"); updateAnime.ModificationDate.Should().HaveDay(DateTime.UtcNow.Day); } }
// public DetailsViewModel EditExisting(Anime anime) { Editing = true; Anime = anime; SetupImage(); ExitCommand = new RelayCommand(() => { AnimeRepository.Save(); MessengerInstance.Send(Display.Anime); }); DetailsBar = SimpleIoc.Default.GetInstance <DetailsBarViewModel>().Load(Anime); NextCommand = new RelayCommand(Next); PreviousCommand = new RelayCommand(Previous); // Button Text = "Edit"; Command = new RelayCommand( Edit, () => Anime?.Name?.Length > 0 ); Anime.PropertyChanged -= AnimeOnPropertyChanged; Anime.PropertyChanged += AnimeOnPropertyChanged; return(this); }
public async Task <int> DownloadSpecificEpisodes(Dictionary <Anime, List <int> > animes, Action <string> output) { var downloaded = 0; foreach (var anime in animes.Keys) { foreach (var episode in animes[anime]) { var download = await AttemptDownload(anime, episode, await GetMedia(anime, episode), output); if (download) { downloaded++; anime.Details.NeedsUpdating = true; } } } if (downloaded > 0) { AnimeRepository.Save(); } return(downloaded); }
private UpdateAnimeHandler CreateHandler(SeiyuuMoeContext dbcontext, IMalApiService apiService) { var animeRepository = new AnimeRepository(dbcontext); var seasonRepository = new SeasonRepository(dbcontext); return(new UpdateAnimeHandler(animeRepository, seasonRepository, apiService)); }
private static InsertSeiyuuHandler CreateHandler(SeiyuuMoeContext dbContext) { var scheduleConfiguration = ConfigurationReader.MalBgJobsScheduleConfiguration; var animeRepository = new AnimeRepository(dbContext); var seiyuuRepository = new SeiyuuRepository(dbContext); var characterRepository = new CharacterRepository(dbContext); var animeRoleRepository = new AnimeRoleRepository(dbContext); var seasonRepository = new SeasonRepository(dbContext); var jikanUrl = ConfigurationReader.JikanUrl;; var jikanConfiguration = new JikanClientConfiguration { Endpoint = jikanUrl, SuppressException = true }; var jikanClient = new Jikan(jikanConfiguration); var jikanService = new JikanService(jikanClient); var s3Client = new S3Service(); return(new InsertSeiyuuHandler( scheduleConfiguration.InsertSeiyuuBatchSize, scheduleConfiguration.DelayBetweenCallsInSeconds, seiyuuRepository, seasonRepository, characterRepository, animeRepository, animeRoleRepository, jikanService, s3Client )); }
public async Task GetOrderedPageByPopularityAsync_GivenMultipleAnime_ShouldReturnAll() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); var anime1 = new AnimeBuilder().WithTitle("Test1").Build(); var anime2 = new AnimeBuilder().WithTitle("Test2").Build(); var anime3 = new AnimeBuilder().WithTitle("Test3").Build(); await dbContext.Animes.AddAsync(anime1); await dbContext.Animes.AddAsync(anime2); await dbContext.Animes.AddAsync(anime3); await dbContext.SaveChangesAsync(); // When var result = await repository.GetOrderedPageByPopularityAsync(x => true); // Then using (new AssertionScope()) { result.TotalCount.Should().Be(3); result.Results.Should().HaveCount(3); } }
// POST: api/Serie public string Post([FromBody] Anime anime) { var repo = new AnimeRepository(); string result = repo.Save(anime); return(result); }
private SearchAnimeQueryHandler CreateHandler(SeiyuuMoeContext seiyuuMoeContext) { var animeRepository = new AnimeRepository(seiyuuMoeContext); var animeSearchCriteriaService = new AnimeSearchCriteriaService(); return(new SearchAnimeQueryHandler(animeRepository, animeSearchCriteriaService)); }
// GET: api/Serie/5 public IEnumerable <Anime> Get(int id) { var repo = new AnimeRepository(); List <Anime> anime = repo.GetAnimeUsuario(id); return(anime); }
// GET: api/Anime public IEnumerable <Anime> Get() { var repo = new AnimeRepository(); List <Anime> animes = repo.GetAnimes(); return(animes); }
public ActionResult EditAnime(AnimeViewModel viewModel) { if (LoginUserSession.Current.IsAuthenticated) { if (viewModel == null) { TempData["Message"] = "No View Model"; return(RedirectToAction("Edit")); } AnimeRepository repo = new AnimeRepository(); Anime anime = repo.GetByID(viewModel.ID); if (anime == null) { anime = new Anime(); } anime.Name = viewModel.Name; anime.AnimeCategory = viewModel.Category; anime.Category = viewModel.CategoryID; anime.Rating = viewModel.Rating; repo.Save(anime); TempData["Mesage"] = "Anime was successfully saved!"; return(RedirectToAction("Edit")); } TempData["ErrorMessage"] = "Please log in"; return(RedirectToAction("Login", "Login")); }
public ActionResult EditAnime(int id = 0) { if (!LoginUserSession.Current.IsAdministrator) { return(RedirectToAction("Edit")); } CategoryRepository categoriesRepo = new CategoryRepository(); List <Category> categories = categoriesRepo.GetAll(); Category category = new Category(); ViewBag.Categories = new SelectList(categories, "ID", "Name"); AnimeRepository animeRepo = new AnimeRepository(); AnimeViewModel anime; if (id != 0) { anime = new AnimeViewModel(animeRepo.GetByID(id)); } else { anime = new AnimeViewModel(new Anime()); } return(View(anime)); }
public async Task <int> DownloadAll(IEnumerable <Anime> animes, Action <string> output) { var downloaded = 0; foreach (var anime in animes) { var result = await GetMedia(anime, anime.NextEpisode); var download = await AttemptDownload(anime, anime.NextEpisode, result, output); if (download) { downloaded++; anime.Episode++; anime.Details.NeedsUpdating = true; } } if (downloaded > 0) { AnimeRepository.Save(); } return(downloaded); }
public async Task GetOrderedPageByPopularityAsync_GivenMultipleWithPredicate_ShouldReturnEmpty() { // Given const int pageSize = 2; const int pageNumber = 2; var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); var anime1 = new AnimeBuilder().WithTitle("Test1").Build(); var anime2 = new AnimeBuilder().WithTitle("Test2").Build(); var anime3 = new AnimeBuilder().WithTitle("Test3").Build(); await dbContext.Animes.AddAsync(anime1); await dbContext.Animes.AddAsync(anime2); await dbContext.Animes.AddAsync(anime3); await dbContext.SaveChangesAsync(); // When var result = await repository.GetOrderedPageByPopularityAsync(x => x.Title.EndsWith("1"), pageNumber, pageSize); // Then// Then using (new AssertionScope()) { result.TotalCount.Should().Be(1); result.Results.Should().BeEmpty(); result.Page.Should().Be(pageNumber); result.PageSize.Should().Be(pageSize); } }
public async Task GetAllBySeasonAndTypeAsync_GivenMultipleAnimeOnlyOneInSeasonWithType_ShouldReturnSingle() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); const int seasonId1 = 100; const int seasonId2 = 101; const AnimeTypeId animeTypeId = AnimeTypeId.TV; var animeType = new AnimeTypeBuilder().WithId(animeTypeId).Build(); var season1 = new SeasonBuilder().WithId(seasonId1).WithName("Winter").WithYear(2000).Build(); var season2 = new SeasonBuilder().WithId(seasonId2).WithName("Spring").WithYear(2000).Build(); var anime1 = new AnimeBuilder().WithTitle("Test1").WithSeason(season1).WithAnimeType(animeType).Build(); var anime2 = new AnimeBuilder().WithTitle("Test2").WithSeason(season1).WithAnimeType(animeType).Build(); var anime3 = new AnimeBuilder().WithTitle("Test3").WithSeason(season2).WithAnimeType(animeType).Build(); await dbContext.Animes.AddAsync(anime1); await dbContext.Animes.AddAsync(anime2); await dbContext.Animes.AddAsync(anime3); await dbContext.SaveChangesAsync(); // When var result = await repository.GetAllBySeasonAndTypeAsync(seasonId2, animeTypeId); // Then result.Should().ContainSingle(); }
public ActionResult Edit() { AnimeRepository repo = new AnimeRepository(); AnimeViewModel model = new AnimeViewModel(repo.GetAll()); return(View(model)); }
public UnitOfWork(ANDbContext context) { _context = context; Animes = new AnimeRepository(_context); Favorites = new FavoriteRepository(_context); Forums = new ForumRepository(_context); Messages = new MessageRepository(_context); Genres = new GenreRepository(_context); Ratings = new RatingRepository(_context); Studios = new StudioRepository(_context); }
private static UpdateAnimeHandler CreateHandler(SeiyuuMoeContext dbContext) { var animeRepository = new AnimeRepository(dbContext); var seasonRepository = new SeasonRepository(dbContext); var jikanUrl = ConfigurationReader.JikanUrl; var jikanClient = new Jikan(jikanUrl); var jikanService = new JikanService(jikanClient); return(new UpdateAnimeHandler(animeRepository, seasonRepository, jikanService)); }
public void UpdateAsync_GivenNotExistingAnime_ShouldThrowExcepton() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); // When Func <Task> func = repository.Awaiting(x => x.UpdateAsync(new AnimeBuilder().WithId(Guid.NewGuid()).Build())); // Then func.Should().Throw <Exception>(); }
public async Task CountAsync_GivenNoAnime_ShouldReturnZero() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); // When var result = await repository.GetAnimeCountAsync(); // Then result.Should().Be(0); }
/// <summary> /// A one time but potentially expensive cost to find out the preferred name /// </summary> private async Task <IEnumerable <RemoteMedia> > GetMedia(Anime anime, int episode) { IEnumerable <RemoteMedia> media; // If there is both an english and romanji title if (!string.IsNullOrEmpty(anime.Details.Title) && !string.IsNullOrEmpty(anime.Details.English)) { if (!string.IsNullOrEmpty(anime.Details.PreferredSearchTitle)) { media = await FindAllMedia(anime, anime.Details.PreferredSearchTitle, episode); } // If there is no preference toward either of them, time to set them else { var english = (await FindAllMedia(anime, anime.Details.English, episode)).ToList(); var romanji = (await FindAllMedia(anime, anime.Details.Title, episode)).ToList(); var englishScore = HealthScore(english); var romanjiScore = HealthScore(romanji); // Set it to romanji, but don't save any titles if (englishScore == -1 && romanjiScore == -1) { media = romanji; } else if (englishScore > romanjiScore) { anime.Details.PreferredSearchTitle = anime.Details.English; media = english; } else { anime.Details.PreferredSearchTitle = anime.Details.Title; media = romanji; } AnimeRepository.Save(); } } else { media = await FindAllMedia(anime, anime.Name, episode); } return(media); }
private static UpdateAnimeHandler CreateHandler(SeiyuuMoeContext dbContext) { var animeRepository = new AnimeRepository(dbContext); var seasonRepository = new SeasonRepository(dbContext); var jikanUrl = ConfigurationReader.JikanUrl;; var jikanConfiguration = new JikanClientConfiguration { Endpoint = jikanUrl, SuppressException = true }; var jikanClient = new Jikan(jikanConfiguration); var jikanService = new JikanService(jikanClient); return(new UpdateAnimeHandler(animeRepository, seasonRepository, jikanService)); }
private static ScheduleAnimesHandler CreateHandler(SeiyuuMoeContext dbContext) { var animeRepository = new AnimeRepository(dbContext); var queueUrl = Environment.GetEnvironmentVariable("AnimeToUpdateQueueUrl"); var animeUpdatePublisher = new SqsAnimeUpdatePublisher(new AmazonSQSClient(), queueUrl); var scheduleConfiguration = ConfigurationReader.MalBgJobsScheduleConfiguration; return(new ScheduleAnimesHandler( scheduleConfiguration.UpdateBatchSize, scheduleConfiguration.DelayBetweenMessagesInSeconds, animeRepository, animeUpdatePublisher )); }
public async Task AddAsync_GivenEmptyAnime_ShouldAddAnime() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); // When await repository.AddAsync(new AnimeBuilder().Build()); // Then var allAnime = await dbContext.Animes.ToListAsync(); allAnime.Should().ContainSingle(); }
public async Task AddAsync_GivenAnime_ShouldAddAnime() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); const string expectedTitle = "ExpectedTitle"; const string expectedImageUrl = "ExpectedImageUrl"; const string expectedJapaneseTitle = "期待される日本語タイトル"; const string expectedTitleSynonyms = "expectedTitleSynonyms"; const string expectedAbout = "ExpectedAbout"; const string expectedStatus = "ExpectedStatus"; var expectedType = AnimeTypeId.TV; const long expectedMalId = 1; var anime = new AnimeBuilder() .WithTitle(expectedTitle) .WithImageUrl(expectedImageUrl) .WithMalId(expectedMalId) .WithJapaneseTitle(expectedJapaneseTitle) .WithTitleSynonyms(expectedTitleSynonyms) .WithAbout(expectedAbout) .WithAnimeType(at => at.WithId(expectedType)) .WithAnimeStatus(at => at.WithName(expectedStatus)) .Build(); // When await repository.AddAsync(anime); // Then var allAnime = await dbContext.Animes.ToListAsync(); var newAnime = await dbContext.Animes.FirstOrDefaultAsync(); using (new AssertionScope()) { allAnime.Should().ContainSingle(); newAnime.Should().NotBeNull(); newAnime.Title.Should().Be(expectedTitle); newAnime.ImageUrl.Should().Be(expectedImageUrl); newAnime.MalId.Should().Be(expectedMalId); newAnime.KanjiTitle.Should().Be(expectedJapaneseTitle); newAnime.TitleSynonyms.Should().Be(expectedTitleSynonyms); newAnime.About.Should().Be(expectedAbout); newAnime.Type.Id.Should().Be(expectedType); newAnime.Status.Description.Should().Be(expectedStatus); } }
private static UpdateSeiyuuHandler CreateHandler(SeiyuuMoeContext dbContext) { var animeRepository = new AnimeRepository(dbContext); var seiyuuRepository = new SeiyuuRepository(dbContext); var characterRepository = new CharacterRepository(dbContext); var seiyuuRoleRepository = new SeiyuuRoleRepository(dbContext); var animeRoleRepository = new AnimeRoleRepository(dbContext); var seasonRepository = new SeasonRepository(dbContext); var jikanUrl = ConfigurationReader.JikanUrl; var jikanClient = new Jikan(jikanUrl, true); var jikanService = new JikanService(jikanClient); return(new UpdateSeiyuuHandler(seiyuuRepository, animeRepository, characterRepository, seiyuuRoleRepository, animeRoleRepository, seasonRepository, jikanService)); }
public async Task AddAsync_GivenDuplicatedKeyAnime_ShouldThrowException() { // Given var id = Guid.NewGuid(); var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); await repository.AddAsync(new AnimeBuilder().WithId(id).Build()); // When Func <Task> func = repository.Awaiting(x => x.AddAsync(new AnimeBuilder().WithId(id).Build())); // Then func.Should().Throw <Exception>(); }
public async Task GetOrderedPageByPopularityAsync_GivenNoAnime_ShouldReturnEmpty() { // Given var dbContext = InMemoryDbProvider.GetDbContext(); var repository = new AnimeRepository(dbContext); // When var result = await repository.GetOrderedPageByPopularityAsync(x => true); // Then using (new AssertionScope()) { result.TotalCount.Should().Be(0); result.Results.Should().BeEmpty(); } }