Ejemplo n.º 1
0
        public async Task <FilmDto> GetAsync(int id, FilmFilter filter = null)
        {
            var result = await filmRepository.GetAsync(id);

            var resultDto = mapper.Map <FilmDto>(result);

            return(resultDto);
        }
Ejemplo n.º 2
0
        public Task <Film> GetAsync(int FilmId, FilmFilter filter = null)
        {
            var film = dbContext.Films.Include(f => f.Sessions)
                       .ThenInclude(f => f.Cinema)
                       .Single(f => f.FilmId == FilmId);

            return(Task.FromResult(film));
        }
Ejemplo n.º 3
0
        public async Task <IEnumerable <FilmDto> > FindAsync(FilmFilter filter = null)
        {
            var result = await filmRepository.FindAsync();

            var resultDto = mapper.Map <IEnumerable <FilmDto> >(result);

            return(resultDto);
        }
Ejemplo n.º 4
0
        public Task <IEnumerable <Film> > FindAsync(FilmFilter filter = null)
        {
            var films = dbContext.Films
                        .AsNoTracking()
                        .Include(f => f.Sessions)
                        .AsEnumerable();

            return(Task.FromResult(films));
        }
Ejemplo n.º 5
0
        public IActionResult GetFilmSessions(int filmId, [FromQuery] FilmFilter filter)
        {
            GetResult <IEnumerable <ResponseSessionDisplayInfo> > result = filmService.GetFilmSessions(filmId, filter);

            if (result.ResultOk)
            {
                return(Ok(result));
            }
            else
            {
                return(NotFound(result));
            }
        }
Ejemplo n.º 6
0
        private IQueryable <Session> CreateFilteredFilmSessionsQuery(int filmId, FilmFilter filter)
        {
            IQueryable <Session> query = dbContext.Sessions
                                         .Where(s => s.Film.FilmId == filmId)
                                         .Include(s => s.Film)
                                         .Include(s => s.CinemaRoom)
                                         .Include(s => s.CinemaRoom.Cinema)
                                         .AsNoTracking();

            if (filter.StartDate != null)
            {
                query = query.Where(s => filter.StartDate < s.BeginTime);
            }
            if (filter.EndDate != null)
            {
                query = query.Where(s => s.BeginTime < filter.EndDate);
            }

            return(query);
        }
Ejemplo n.º 7
0
        public GetResult <IEnumerable <ResponseSessionDisplayInfo> > GetFilmSessions(int filmId, FilmFilter filters)
        {
            if (!FilmExists(filmId))
            {
                return(new GetResult <IEnumerable <ResponseSessionDisplayInfo> >
                {
                    ResultOk = false,
                    Details = "Such film does not exist."
                });
            }

            return(new GetResult <IEnumerable <ResponseSessionDisplayInfo> >
            {
                ResultOk = true,
                RequestedData = CreateFilteredFilmSessionsQuery(filmId, filters)
                                .Select(s => new ResponseSessionDisplayInfo
                {
                    SessionId = s.SessionId,
                    Film = new ResponseFilmDisplayInfo
                    {
                        FilmId = s.FilmId,
                        Name = s.Film.Name
                    },
                    Cinema = new ResponseCinemaDisplayInfo
                    {
                        Name = s.CinemaRoom.Cinema.Name,
                        City = s.CinemaRoom.Cinema.City,
                        CinemaId = s.CinemaRoom.Cinema.CinemaId
                    },
                    CinemaRoom = new ResponseCinemaRoomDisplayInfo
                    {
                        Name = s.CinemaRoom.Name,
                        CinemaRoomId = s.CinemaRoomId
                    },
                    BeginTime = s.BeginTime
                })
            });
        }