public async Task <IActionResult> Detail(int Id)
{
FilmData data = await _service.GetFilmDetailById(Id);
ViewBag.Title = $"{data.Name} - 详情";
return(View(data));
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
base.OnNavigatedTo(e);
SpeechSynthesisService.CancelExistingRequests();
if (bLoaded)
{
return;
}
if (!Config.ShowCleanBackground)
{
this.LayoutRoot.Background = new ImageBrush()
{
ImageSource = new BitmapImage(new Uri("SplashScreenImage-WVGA.jpg", UriKind.Relative)),
Opacity = 0.2,
Stretch = Stretch.UniformToFill
};
}
List <FilmInfo> current = new List <FilmInfo>();
List <FilmInfo> upcomig = new List <FilmInfo>();
foreach (var film in App.Films.Values)
{
if (film.Release <= DateTime.UtcNow)
{
current.Add(film);
}
else
{
upcomig.Add(film);
}
}
this.lstMain.IsGroupingEnabled = this.lstUpcoming.IsGroupingEnabled = Config.GroupData;
if (Config.GroupData)
{
FilmData cdCurrent = new FilmData(current);
var dataLetter = cdCurrent.GetGroupsByLetter();
this.lstMain.ItemsSource = dataLetter.ToList();
FilmData cdUpcoming = new FilmData(upcomig);
var dataLetterUpcoming = cdUpcoming.GetGroupsByLetter();
this.lstUpcoming.ItemsSource = dataLetterUpcoming.ToList();
}
else
{
this.lstMain.ItemsSource = current;
this.lstUpcoming.ItemsSource = upcomig;
}
bLoaded = true;
}
public List <FilmModel> GetAllByTitle(string title)
{
FilmData data = new FilmData(_config);
var output = data.GetAllByTitle(title);
return(output);
}
public FilmModel GetById(int id)
{
FilmData data = new FilmData(_config);
var output = data.GetById(id);
return(output);
}
public List <FilmModel> Get()
{
FilmData data = new FilmData(_config);
var output = data.GetAll();
return(output);
}
///<summary>
/// Converts FilmData object to FilmUpdateInputModel
///</summary>
///<param name="filmData"> FilmData object to map from</param>
///<returns>Mapped instance of type <see cref="FilmUpdateInputModel"/></returns>
public FilmUpdateInputModel MapToFilmUpdateInputModel(FilmData filmData)
{
var viewModel = MapSimilarProperties <FilmData, FilmUpdateInputModel>(filmData);
if (filmData != null)
{
viewModel.Genre = filmData.Genre.Select(x => x.Genre).ToList();
}
return(viewModel);
}
/// <summary>
/// Updates the data about a selected film
/// </summary>
/// <param name="filmData">The updated data of the film</param>
public async Task UpdateAsync(FilmData filmData)
{
var filmDataInContext = await context.FilmDatas.FindAsync(filmData.FilmId);
if (filmDataInContext != null)
{
context.Entry(filmDataInContext).CurrentValues.SetValues(filmData);
await context.SaveChangesAsync();
}
}
public ActionResult NewFilm(FilmData f)
{
if (ModelState.IsValid)
{
return(View());
}
else
{
return(View(f));
}
}
public static DateTime?GetEndDate(this FilmData src)
{
var lastYear = GetLastYear(src.Year);
if (lastYear != null)
{
return(new DateTime(lastYear.Value, 12, 31));
}
return(null);
}
///<summary>
/// Converts FilmData object to FilmCardViewModel
///</summary>
///<param name="filmData">FilmData object to map from </param>
/// <returns>Mapped instance of type <see cref="FilmCardViewModel"/></returns>
public FilmCardViewModel MapToFilmCardViewModel(FilmData filmData)
{
return(new FilmCardViewModel
{
Title = filmData.Title,
Genres = string.Join(", ", filmData.Genre.Select(a => a.Genre.ToString())),
Poster = filmData.Poster,
Rating = Math.Round(filmData.Film.Rating, 1).ToString(),
Id = filmData.FilmId
});
}
private void NameMovie_SelectedIndexChanged(object sender, EventArgs e)
{
if (_core.Films.Count != 0)
{
if (NameMovie.SelectedIndex != -1)
{
_tmpData = _core.Films[NameMovie.SelectedIndex];
TimeFilm.Value = _tmpData.Time;
_index = NameMovie.SelectedIndex;
}
}
}
///<summary>
/// Converts FilmData object to ExtendedFilmCardViewModel
///</summary>
///<param name="filmData"> FilmData object to map from</param>
///<returns>Mapped instance of type <see cref="ExtendedFilmCardViewModel"/></returns>
public ExtendedFilmCardViewModel MapToExtendedFilmCardViewModel(FilmData filmData)
{
var viewModel = MapSimilarProperties <FilmData, ExtendedFilmCardViewModel>(filmData);
if (filmData != null)
{
viewModel.Id = filmData.FilmId;
viewModel.Genres = string.Join(", ", filmData.Genre.Select(a => a.Genre.ToString()));
viewModel.Rating = Math.Round(filmData.Film.Rating, 1).ToString();
}
return(viewModel);
}
public void Initialise(CinemaInfo selectedCinema, List <FilmInfo> films)
{
this.CinemaDetails = selectedCinema;
this.filmData = new FilmData(films);
List <FilmInfo> currentFilms = new List <FilmInfo>();
List <FilmInfo> upcomingFilms = new List <FilmInfo>();
foreach (var film in films)
{
if (film.Release <= DateTime.UtcNow)
{
currentFilms.Add(film);
}
else
{
upcomingFilms.Add(film);
}
}
foreach (var currentFilm in currentFilms)
{
this.Current.Add(currentFilm);
}
foreach (var upcomingFilm in upcomingFilms)
{
this.Upcoming.Add(upcomingFilm);
}
this.GroupCurrent = new ObservableCollection <Group <FilmInfo> >(new FilmData(currentFilms).GetGroupsByLetter());
this.GroupUpcoming = new ObservableCollection <Group <FilmInfo> >(new FilmData(upcomingFilms).GetGroupsByLetter());
this.SetFilmsForDate(DateTime.Today);
this.RaisePropertyChanged("CinemaDetails");
this.RaisePropertyChanged("Current");
this.RaisePropertyChanged("Upcoming");
this.RaisePropertyChanged("FilmsForDate");
this.RaisePropertyChanged("GroupCurrent");
this.RaisePropertyChanged("GroupUpcoming");
this.RaisePropertyChanged("GroupFilmsForDate");
this.RaisePropertyChanged("FilmAppointmentSource");
this.RaisePropertyChanged("FirstCinemaDate");
this.RaisePropertyChanged("LastCinemaDate");
this.RaisePropertyChanged("UserSelectedDate");
this.Initialised = true;
}
///<summary>
/// Creates FilmProjection object
///</summary>
///<param name="input">Projection data to map from</param>
///<param name="film"> Film object to map from</param>
///<param name="cinema"> Cinema object to map from</param>
///<returns>Mapped instance of type <see cref="FilmProjection"/></returns>
public FilmProjection MapToFilmProjection(ProjectionInputModel input, FilmData film, Cinema cinema)
{
return(new FilmProjection
{
CinemaId = cinema.Id,
Date = input.Date,
FilmId = film.FilmId,
ProjectionType = input.ProjectionType,
TotalTickets = input.TotalTickets,
TicketPrices = new TicketPrices
{
AdultPrice = input.AdultsTicketPrice,
StudentPrice = input.StudentsTicketPrice,
ChildrenPrice = input.ChildrenTicketPrice
}
});
}
public async Task <IActionResult> Edit(string id, [Bind("FilmId,Title,Poster,Description,Director,Cast,Runtime,ReleaseDate,TargetAudience")] FilmData filmData)
{
var dataInContext = await filmDataBusiness.GetAsync(id);
if (id != filmData.FilmId || dataInContext == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await filmDataBusiness.UpdateAsync(filmData);
return(RedirectToAction(nameof(Details), new { id }));
}
return(View(filmData));
}
///<summary>
/// Converts FilmData object to FilmDataViewModel
///</summary>
///<param name="filmData"> FilmData object to map from </param>
///<returns>Mapped instance of type <see cref="FilmDataViewModel"/></returns>
public FilmDataViewModel MapToFilmDataViewModel(FilmData filmData)
{
var viewModel = MapSimilarProperties <FilmData, FilmDataViewModel>(filmData);
if (filmData != null)
{
viewModel.Id = filmData.FilmId;
viewModel.Genres = string.Join(", ", filmData.Genre.Select(a => a.Genre.ToString()));
viewModel.Rating = Math.Round(filmData.Film.Rating, 1).ToString();
viewModel.FilmProjections = filmData.Film.FilmProjection.Select(x => MapToProjectionCardViewModel(x))
.OrderByDescending(x => x.Date)
.ToList();
viewModel.FilmReviews = filmData.Film.FilmReviews.Select(x => MapToFilmReviewViewMode(x))
.OrderByDescending(x => x.CreatedOn)
.ToList();
viewModel.CreatedByUserId = filmData.Film.AddedByUserId;
}
return(viewModel);
}
public static DateTime?GetPremiereDate(this FilmData src)
{
var res = src.IsRussianSpokenOriginated()
? src.PremiereRu
: src.PremiereWorld;
if (src.PremiereRu < res)
{
res = src.PremiereRu;
}
if (src.PremiereWorld < res)
{
res = src.PremiereWorld;
}
if (src.PremiereDigital < res)
{
res = src.PremiereDigital;
}
if (src.PremiereDvd < res)
{
res = src.PremiereDvd;
}
if (src.PremiereBluRay < res)
{
res = src.PremiereBluRay;
}
if (res.HasValue)
{
return(res);
}
var firstYear = GetFirstYear(src.Year);
if (firstYear != null)
{
return(new DateTime(firstYear.Value, 1, 1));
}
return(null);
}
public async Task OnGetAsync(int?id, int?categoryID)
{
FilmD = new FilmData();
FilmD.Films = await _context.Film
.Include(b => b.Director)
.Include(b => b.FilmCategories)
.ThenInclude(b => b.Category)
.AsNoTracking()
.OrderBy(b => b.Title)
.ToListAsync();
if (id != null)
{
FilmID = id.Value;
Film film = FilmD.Films
.Where(i => i.ID == id.Value).Single();
FilmD.Categories = film.FilmCategories.Select(s => s.Category);
}
}
public static List <FilmModel> Map(FilmData filmData)
{
var response = new List <FilmModel>();
foreach (var film in filmData.Search)
{
if (film.Poster.ToUpper().Equals("N/A"))
{
continue;
}
var filmModel = new FilmModel
{
Identifier = film.ImdbId,
Poster = film.Poster
};
response.Add(filmModel);
}
return(response);
}
private void CountFilms_ValueChanged(object sender, EventArgs e)
{
if (CountFilms.Value > _countFilms)
{
FilmData[] filmData = new FilmData[(int)CountFilms.Value - _countFilms];
for (int i = 0; i < filmData.Length; i++)
{
filmData[i] = new FilmData("Фильм " + indexName++, DefaultTime);
}
_core.Films.AddRange(filmData);
}
else if (CountFilms.Value < _countFilms)
{
int tmp = _countFilms - (int)CountFilms.Value;
for (int i = 0; i < tmp; i++)
{
_core.Films.RemoveAt(_core.Films.Count - 1);
indexName--;
}
}
_countFilms = (int)CountFilms.Value;
FilmsSource.ResetBindings(true);
}
private void LoadFilmList(List <FilmInfo> films)
{
cd = new FilmData(films);
this.dpShowing.Value = DateTime.Today;
this.lstShowByDate.ItemsSource = FilmsForSelectedDate;
this.SetFilmsForSelectedDate(DateTime.Today);
List <FilmInfo> current = new List <FilmInfo>();
List <FilmInfo> upcomig = new List <FilmInfo>();
foreach (var film in films)
{
if (film.Release <= DateTime.UtcNow)
{
current.Add(film);
}
else
{
upcomig.Add(film);
}
}
FilmData cdCurrent = new FilmData(current);
var dataLetterCurrent = cdCurrent.GetGroupsByLetter();
this.lstCurrent.ItemsSource = dataLetterCurrent;
FilmData cdUpcoming = new FilmData(upcomig);
var dataLetterUpcoming = cdUpcoming.GetGroupsByLetter();
this.lstUpcoming.ItemsSource = dataLetterUpcoming;
}
/// <summary>
/// 根据Id获取详细信息
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public async Task <FilmData> GetFilmDetailById(int Id)
{
string sql = "SELECT * FROM dbo.Film1905 WHERE Id=@Id";
DynamicParameters parameters = new DynamicParameters();
parameters.Add("Id", Id);
return(await Task.Factory.StartNew(() =>
{
try
{
using (IDbConnection connection = this.GetConnection())
{
FilmData film = connection.Query <FilmData>(sql, parameters).FirstOrDefault();
return film;
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Query film, Id:{Id}");
return null;
}
}));
}
private void TimeFilm_ValueChanged(object sender, EventArgs e)
{
_tmpData = _core.Films[NameMovie.SelectedIndex];
_tmpData.Time = (int)TimeFilm.Value;
}
public void GetWatchListReturnsAllElements()
{
// Arrange
var filmData1 = new FilmData
{
Title = "Title1",
Genre = new List <GenreType> {
new GenreType {
Genre = Genre.Action
}
},
Poster = "Poster1",
FilmId = "Film1"
};
var filmData2 = new FilmData
{
Title = "Title2",
Genre = new List <GenreType> {
new GenreType {
Genre = Genre.Action
}
},
Poster = "Poster2",
FilmId = "Film2"
};
var film1 = new Film
{
Rating = 2,
Id = "Film1",
FilmData = filmData1
};
var film2 = new Film
{
Rating = 3,
Id = "Film2",
FilmData = filmData2
};
filmData1.Film = film1;
filmData2.Film = film2;
var user = new CinemaUser {
WatchList = new List <Film> {
film1, film2
}
};
var users = new List <CinemaUser> {
user
}.AsQueryable();
var mockSet = new Mock <DbSet <CinemaUser> >();
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Provider).Returns(users.Provider);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Expression).Returns(users.Expression);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());
var mockContext = new Mock <CinemaDbContext>();
mockContext.Setup(c => c.Users).Returns(mockSet.Object);
mockContext.Setup(s => s.Users.FindAsync(It.IsAny <string>())).Returns(new ValueTask <CinemaUser>(user));
var filmBusiness = new FilmBusiness(mockContext.Object);
var mapper = new Mapper();
var expectedWatchList = user.WatchList.Select(x => mapper.MapToFilmCardViewModel(x.FilmData)).ToList();
// Act
var resultWatchList = filmBusiness.GetWatchList(user.Id, mapper.MapToFilmCardViewModel).ToList();
// Assert
Assert.AreEqual(expectedWatchList.Count, resultWatchList.Count, "Incorrect watchlist returned");
Assert.AreEqual(expectedWatchList[0].Id, resultWatchList[0].Id, "Incorect data returned");
Assert.AreEqual(expectedWatchList[0].Poster, resultWatchList[0].Poster, "Incorect data returned");
Assert.AreEqual(expectedWatchList[0].Rating, resultWatchList[0].Rating, "Incorect data returned");
Assert.AreEqual(expectedWatchList[0].Title, resultWatchList[0].Title, "Incorect data returned");
Assert.AreEqual(expectedWatchList[0].Genres, resultWatchList[0].Genres, "Incorect data returned");
Assert.AreEqual(expectedWatchList[1].Id, resultWatchList[1].Id, "Incorect data returned");
}
public void GetWatchListReturnsNoElementsForInvalidUser()
{
// Arrange
var filmData1 = new FilmData
{
Title = "Title1",
Genre = new List <GenreType> {
new GenreType {
Genre = Genre.Action
}
},
Poster = "Poster1",
FilmId = "Film1"
};
var filmData2 = new FilmData
{
Title = "Title2",
Genre = new List <GenreType> {
new GenreType {
Genre = Genre.Action
}
},
Poster = "Poster2",
FilmId = "Film2"
};
var film1 = new Film
{
Rating = 2,
Id = "Film1",
FilmData = filmData1
};
var film2 = new Film
{
Rating = 3,
Id = "Film2",
FilmData = filmData2
};
filmData1.Film = film1;
filmData2.Film = film2;
var user = new CinemaUser
{
WatchList = new List <Film> {
film1, film2
}
};
var users = new List <CinemaUser> {
user
}.AsQueryable();
var mockSet = new Mock <DbSet <CinemaUser> >();
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Provider).Returns(users.Provider);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.Expression).Returns(users.Expression);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.ElementType).Returns(users.ElementType);
mockSet.As <IQueryable <CinemaUser> >().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());
var mockContext = new Mock <CinemaDbContext>();
mockContext.Setup(c => c.Users).Returns(mockSet.Object);
mockContext.Setup(s => s.Users.FindAsync(It.IsAny <string>())).
Returns(new ValueTask <CinemaUser>(Task.FromResult((CinemaUser)null)));
var filmBusiness = new FilmBusiness(mockContext.Object);
var mapper = new Mapper();
var expectedWatchList = new List <FilmCardViewModel>();
// Act
var resultWatchList = filmBusiness.GetWatchList("UnexistingUserId", mapper.MapToFilmCardViewModel);
// Assert
Assert.AreEqual(null, resultWatchList, "Incorrect watchlist returned");
}
public static bool IsRussianSpokenOriginated(this FilmData src) => src?.Countries?.IsRussianSpokenOriginated() ?? false;
public static bool IsContinuing(this FilmData src) => IsСontinuing(src?.Year);
