private SeriesService CreateSeriesService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new SeriesService(userId);
return(service);
}
public ActionResult Index()
{
ShopIndexViewModel model = new ShopIndexViewModel();
model.series = SeriesService.GetSeries().ToArray();
return(View(model));
}
public void UpdateVideo_ChangingSeries_ShouldRemoveVideoFromSequence()
{
var seriesService = new SeriesService();
var sequenceRepository = new SeriesSequenceRepository();
var series = seriesService.CreateAndRetrieveSeries(GetNewSeriesDetails());
var videoDto = GetNewVideoDetails(testLibrary, null, series);
var videoToUpdateId = repository.CreateVideo(videoDto);
var videoToUpdate = repository.GetVideo(videoToUpdateId).Result;
var sequenceDto = new CreateSeriesSequenceDto(series.SeriesId, "title", "desc", -1, true, 2);
var sequenceId = sequenceRepository.CreateVideoSequence(sequenceDto);
var sequence = sequenceRepository.GetSeriesSequence(sequenceId);
sequenceRepository.AddVideoToSequence(videoToUpdateId, sequence.SequenceId);
videoToUpdate.SeriesId = DatabaseConstants.DEFAULT_ID;
repository.UpdateVideo(videoToUpdate).ConfigureAwait(false);
var updatedVideo = repository.GetVideo(videoToUpdateId).Result;
var details = sequenceRepository.GetVideoSeriesChronologyDetails(videoToUpdateId);
Assert.AreEqual(DatabaseConstants.DEFAULT_ID, updatedVideo.SeriesId);
Assert.AreEqual(null, details);
}
public PlayerInfoViewModel()
{
this.playerService = new PlayerService();
this.seriesService = new SeriesService();
this.playerStats = new ObservableCollection <PlayerStats>();
LoadData();
}
public async Task GetAllComicBookSeries()
{
ISeriesService service = new SeriesService();
ISeriesDataAccess dataAccess = new MockSeriesDataAccess();
IEnumerable <ComicBookSeries> issues = service.GetIssues();
}
public DummySeries()
{
this.SeriesDummy = new Series
(
new MatchDuration(new TimeSpan(0, 90, 0)),
new NumberOfTeams(4),
new SeriesName("The Dummy Series")
);
this.DummyTeams = new DummyTeams();
this.SeriesDummy.TeamIds.Add(this.DummyTeams.DummyTeamOne.Id);
this.SeriesDummy.TeamIds.Add(this.DummyTeams.DummyTeamTwo.Id);
this.SeriesDummy.TeamIds.Add(this.DummyTeams.DummyTeamThree.Id);
this.SeriesDummy.TeamIds.Add(this.DummyTeams.DummyTeamFour.Id);
var seriesService = new SeriesService();
seriesService.Add(this.SeriesDummy);
this.GeneratDummySeriesSchedual();
this.DummyGames = new DummyGames(this);
DomainService.AddSeriesToTeam(this.SeriesDummy);
//TODO: Un-comment and run first test in PlayerService to generate bin-files!
//PlayerRepository.instance.SaveData();
//TeamRepository.instance.SaveData();
//GameRepository.instance.SaveData();
//MatchRepository.instance.SaveData();
//SeriesRepository.instance.SaveData();
}
public SeriesServicesTests()
{
this.seriesService = new SeriesService();
this.testSerieOne = new Series(new MatchDuration(new TimeSpan(45 * 6000000000 / 10)), new NumberOfTeams(4), new SeriesName("Allsvenskan"));
this.testSerieOne.TeamIds.Add(Guid.NewGuid());
this.testSerieOne.TeamIds.Add(Guid.NewGuid());
this.testSerieOne.TeamIds.Add(Guid.NewGuid());
this.testSerieOne.TeamIds.Add(Guid.NewGuid());
}
public SeriesScheduleViewModel()
{
matchesBySeriesCollection = new ObservableCollection <Match>();
seriesService = new SeriesService();
Messenger.Default.Register <Series>(this, OnSeriesObjReceived);
LoadData();
}
/// <summary>
/// Initializes a new instance of the ApiService class
/// </summary>
/// <param name="apiPublicKey">The public API key provided by Marvel</param>
/// <param name="apiPrivateKey">The private API key provided by Marvel</param>
public ApiService(string apiPublicKey, string apiPrivateKey)
{
_characterService = ServiceLocator.GetCharacterService(apiPublicKey, apiPrivateKey);
_comicService = ServiceLocator.GetComicService(apiPublicKey, apiPrivateKey);
_creatorService = ServiceLocator.GetCreatorService(apiPublicKey, apiPrivateKey);
_eventService = ServiceLocator.GetEventService(apiPublicKey, apiPrivateKey);
_seriesService = ServiceLocator.GetSeriesService(apiPublicKey, apiPrivateKey);
_storyService = ServiceLocator.GetStoryService(apiPublicKey, apiPrivateKey);
}
private string searchText; //TODO:Continue
public TeamViewModel()
{
this.teams = new ObservableCollection <IExposableTeam>();
this.teamService = new TeamService();
this.seriesService = new SeriesService();
this.LoadData();
Messenger.Default.Register <IExposableTeam>(this, this.OnTeamObjReceived);
}
public ActionResult Product(int id)
{
ShopProductViewModel model = new ShopProductViewModel();
model.series = SeriesService.GetSeries(id).FirstOrDefault();
if (model.series != null)
{
model.series.Products = ProductService.GetProducts(SeriesID: id).ToArray();
}
return(View(model));
}
public void GetVideosInSeries_ShouldntReturnVideosInOtherSeries()
{
var seriesService = new SeriesService();
var series = seriesService.CreateAndRetrieveSeries(GetNewSeriesDetails());
var otherSeries = seriesService.CreateAndRetrieveSeries(GetNewSeriesDetails());
repository.CreateVideo(GetNewVideoDetails(otherSeries));
var videos = repository.GetVideosInSeries(series.SeriesId, GetFirstPage()).Result.Results;
CollectionAssert.AreEquivalent(new List <Video>(), videos);
}
public async void GetCategories()
{
var mapper = GetMapper();
using (var context = GetDbContext())
{
SeedDatabase(context);
var service = new SeriesService(context, mapper);
var categories = await service.GetCategories();
Assert.Equal(3, categories.Count);
}
}
public static Task CreateInvalidSeries()
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new SeriesRepository(context);
var seriesService = new SeriesService(repository);
var seriesId = new SeriesId(SequentialGuid.NewSequentialGuid());
var command = new Commands.Create {
Id = seriesId
};
return(seriesService.Handle(command));
}
public SeriesDetailViewModelTests()
{
var seriesRepoMock = new Mock <IRepository <Series> >();
var seriesService = new SeriesService(seriesRepoMock.Object);
var eventAggregatorMock = new Mock <IEventAggregator>();
var loggerMock = new Mock <ILogger>();
var bookLookupDataServiceMock = new Mock <IBookLookupDataService>();
var dialogService = new DialogService();
viewModel = new SeriesDetailViewModel(eventAggregatorMock.Object, loggerMock.Object,
seriesService, bookLookupDataServiceMock.Object,
dialogService);
}
// DELETE
public static Task RemoveSeries(SeriesId id)
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new SeriesRepository(context);
var seriesService = new SeriesService(repository);
var command = new Commands.Delete
{
Id = id,
};
return(seriesService.Handle(command));
}
public async Task <IActionResult> OnGetAsync()
{
IMTS.setParams("https://www.allportsopen.com", "website", "The All Ports Open Network", "A Podcast Network for Geeks", "https://media.allportsopen.org/Images/LogoSmWText.png");
if (SplashNews == null)
{
var result = await DS.GetAsync("SplashNews/GetThree");
FPI = Newtonsoft.Json.JsonConvert.DeserializeObject <FrontPageInfo>(result);
}
ViewData["SplashNews"] = FPI.SplashNews;
SeriesList = await SeriesService.GetSeriesList(false);
return(Page());
}
public static Task UpdateSeriesName(SeriesId id, string firstName)
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new SeriesRepository(context);
var seriesService = new SeriesService(repository);
var command = new Commands.SetSeriesName
{
Id = id,
Name = firstName
};
return(seriesService.Handle(command));
}
public static Task UpdateSeriesDescription(SeriesId id, string description)
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new SeriesRepository(context);
var seriesService = new SeriesService(repository);
var command = new Commands.SetDescription()
{
Id = id,
Description = description
};
return(seriesService.Handle(command));
}
public static Task UpdateSeriesPicturePath(SeriesId id, string path)
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new SeriesRepository(context);
var seriesService = new SeriesService(repository);
var command = new Commands.SetPicturePath
{
Id = id,
PicturePath = path
};
return(seriesService.Handle(command));
}
/// <summary>
/// Creates a new instance with the provided api configuration
/// </summary>
/// <param name="apiConfiguration">The API configuration</param>
private TVDBManager(TVDBConfiguration apiConfiguration)
{
if (apiConfiguration == null)
{
throw new ArgumentNullException(nameof(apiConfiguration));
}
// Init Services
Authentication = new AuthenticationService(apiConfiguration);
Series = new SeriesService(apiConfiguration);
Episodes = new EpisodesService(apiConfiguration);
Updates = new UpdateService(apiConfiguration);
Actors = new ActorService(apiConfiguration);
this.apiConfiguration = apiConfiguration;
}
public async void GetSeries()
{
var mapper = GetMapper();
using (var context = GetDbContext())
{
SeedDatabase(context);
var service = new SeriesService(context, mapper);
var breakingBad = await service.GetSeries(1);
Assert.True(breakingBad is Series);
Assert.Equal("Breaking Bad", breakingBad.Title);
}
}
public static Task UpdateSeriesReadOrder(SeriesId seriesId, ICollection <ReadOrder> newReadOrder)
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new SeriesRepository(context);
var seriesService = new SeriesService(repository);
var command = new Commands.SetReadOrder
{
Id = seriesId,
Books = newReadOrder
};
return(seriesService.Handle(command));
}
public PagedList <SeriesGrid> Search(SearchModel <SeriesCriteria> searchModel)
{
using (var uow = UnitOfWorkFactory.Create <NovelContext>())
{
var service = new SeriesService(uow);
var results = service.Search(searchModel);
var seriesIDs = results.Data.Select(s => s.ID).ToList();
// latest release
var releases = service.View <Release>().Where(w => seriesIDs.Contains(w.SeriesID)).ToList();
// connectors
var connectors = service.View <Connector>().Where(w => w.IsDeleted == false).Where(w => seriesIDs.Contains(w.SourceID)).ToList();
// tags
var tagTypes = new[] { R.TagType.CATEGORY, R.TagType.GENRE };
var tags = service.View <Tag>().Where(w => w.IsDeleted == false && tagTypes.Contains(w.TagType)).ToList();
// groups
var groupIDs = connectors.Where(w => w.ConnectorType == R.ConnectorType.SERIES_GROUP).Select(s => s.TargetID).ToList();
var groups = service.View <Group>().Where(w => groupIDs.Contains(w.ID)).ToList();
// user lists
var userLists = service.View <UserList>().Where(w => w.IsDeleted == false && w.UserID == searchModel.Criteria.ByUserID).ToList();
// vote
var userVotedSeriesIDs = service.View <UserVote>().Where(w => w.SourceTable == R.SourceTable.SERIES && seriesIDs.Contains(w.SourceID) && w.UserID == searchModel.Criteria.ByUserID)
.Select(s => new { SeriesID = s.SourceID, Vote = s.Vote }).ToList();
// rate
var userQualityRatedSeriesIDs = service.View <UserRate>().Where(w => w.SourceTable == R.SourceTable.SERIES && seriesIDs.Contains(w.SourceID) && w.UserID == searchModel.Criteria.ByUserID)
.Select(s => new { SeriesID = s.SourceID, Rate = s.Rate }).ToList();
var connectorTypes = new[] { R.ConnectorType.SERIES_TAGCATEGORY, R.ConnectorType.SERIES_TAGGENRE };
// convert to PagedList<TranslationSceneGrid>
results.Data = results.Data.Select(s =>
{
s.Releases = releases.Where(w => w.SeriesID == s.ID).ToList();
s.Groups = connectors.Where(w => w.ConnectorType == R.ConnectorType.SERIES_GROUP && w.SourceID == s.ID)
.Join(groups, c => c.TargetID, g => g.ID, (c, g) => g).ToList();
s.UserLists = userLists;
s.Connectors = connectors.Where(w => w.SourceID == s.ID).ToList();
s.Tags = tags.Where(w => connectors.Any(w2 => connectorTypes.Contains(w2.ConnectorType) && w2.SourceID == s.ID && w2.TargetID == w.ID)).ToList();
s.Voted = userVotedSeriesIDs.Where(w => w.SeriesID == s.ID).Select(s2 => s2.Vote).SingleOrDefault();
s.QualityRated = userQualityRatedSeriesIDs.Where(w => w.SeriesID == s.ID).Select(s2 => s2.Rate).SingleOrDefault();
return(s);
}).ToList();
return(results);
}
}
public SeriesViewModel()
{
this.teamsToAddToSeries = new ObservableCollection <Team>();
this.numberOfTeamsList = new List <int>();
this.teamService = new TeamService();
this.seriesService = new SeriesService();
this.AddTeamCommand = new RelayCommand(AddTeam);
this.DeleteTeamCommand = new RelayCommand(DeleteTeam);
this.AddSeriesCommand = new RelayCommand(AddSeriesTeam);
LoadData();
validProperties = new Dictionary <string, bool>();
validProperties.Add("SeriesName", false);
validProperties.Add("MatchDuration", false);
validProperties.Add("SelectedItem", false);
validProperties.Add("TeamsToAddToSeries", false);
}
public async void GetSeasonEpisodes()
{
var mapper = GetMapper();
using (var context = GetDbContext())
{
SeedDatabase(context);
var service = new SeriesService(context, mapper);
var breakingBad = await service.GetSeries(1);
var seasonOne = await service.GetSeasonEpisodes(breakingBad, 1);
Assert.Equal(2, seasonOne.Count);
}
}
public void ShouldDeleteVideo_WhenSeriesDeleted()
{
var seriesService = new SeriesService();
var series = seriesService.CreateAndRetrieveSeries(GetNewSeriesDetails());
var videoToCreate = GetNewVideoDetails(series);
var videoId = repository.CreateVideo(videoToCreate);
seriesService.DeleteSeries(series).ConfigureAwait(false);
var videoRetrieved = repository.GetVideo(videoId).Result;
CollectionAssert.AreEquivalent(new List <Video>()
{
videoRetrieved
}, repository.GetDeletedVideos(GetFirstPage()).Result.Results);
CollectionAssert.AreEquivalent(new List <Video>(), repository.GetVideos(GetFirstPage()).Result.Results);
}
public TeamInfoViewModel()
{
this.allTeamsCollection = new ObservableCollection <IExposableTeam>();
this.seriesCollection = new ObservableCollection <Series>();
this.teamsBySeriesCollection = new ObservableCollection <IExposableTeam>();
this.playersByTeamCollection = new ObservableCollection <IExposablePlayer>();
this.teamlessPlayers = new ObservableCollection <IExposablePlayer>();
this.seriesService = new SeriesService();
this.teamService = new TeamService();
this.playerService = new PlayerService();
Messenger.Default.Register <IExposablePlayer>(this, this.OnPlayerObjectRecieved);
this.LoadData();
this.TeamsCollection = this.allTeamsCollection;
}
//Beérkezésre mi történjen
public override async Task OnNavigatedToAsync(
object parameter, NavigationMode mode, IDictionary <string, object> state)
{
seriesID = (List <int>)parameter;
//Sorozat évadainak lekérése, és objektumba kötése
var seriesService = new SeriesService();
Season = await seriesService.GetSeriesSeasonAsync(seriesID[0], seriesID[1]);
foreach (var item in Season.episodes)
{
EpisodeList.Add(item);
}
await base.OnNavigatedToAsync(parameter, mode, state);
}
public ActionResult Index()
{
HomeIndexViewModel model = new HomeIndexViewModel();
var seriesBag = SeriesService.GetSeries();
var products = new List <Product>();
foreach (var series in seriesBag)
{
products.AddRange(ProductService.GetProducts(SeriesID: series.SeriesID));
}
Random rnd = new Random();
model.ProductBag = products.OrderBy(x => rnd.Next()).Take(5).ToArray();
return(View(model));
}
