示例#1
0
        public static void SeedGenres(IGenreRepository genrerepo)
        {
            using (FileStream fs = File.Open("DataInit\\genres.csv", FileMode.Open, FileAccess.Read, FileShare.None))
            {
                var parser = new Microsoft.VisualBasic.FileIO.TextFieldParser(fs);
                parser.TextFieldType = Microsoft.VisualBasic.FileIO.FieldType.Delimited;
                parser.SetDelimiters(new string[] { "," });

                //genrerepo.Clear();
                genrerepo.SetIdentityInsert(true);

                bool first = true;
                while (!parser.EndOfData)
                {
                    // 0: genreId, 1: genre
                    string[] row = parser.ReadFields();

                    if (first)
                    {
                        first = false;
                        continue;
                    }
                    var genre = new Genre
                    {
                        //GenreId = Int32.Parse(row[0]),
                        Name = row[1]
                    };
                    genrerepo.Create(genre);
                }
                genrerepo.SetIdentityInsert(false);
            }
        }
示例#2
0
        public async Task <IActionResult> Create([FromBody] GenreCreateDTO genreDTO)
        {
            var location = GetControllerActionNames();

            try
            {
                _logger.LogInfo($"{location}: Started Create Genre");
                if (genreDTO == null)
                {
                    _logger.LogError($"{location}: Empty request");
                    return(BadRequest(ModelState));
                }
                if (!ModelState.IsValid)
                {
                    _logger.LogError($"{location}: Wrong model state");
                    return(BadRequest(ModelState));
                }
                var genre     = _mapper.Map <Genre>(genreDTO);
                var IsSuccess = await _genreRepository.Create(genre);

                if (!IsSuccess)
                {
                    return(InternalError($"{location} : Creation failed"));
                }
                return(Created("Create", new { genre }));
            }
            catch (Exception ex)
            {
                return(InternalError($"{location} : Something wrong {ex.Message}"));
            }
        }
        public ActionResult <Genre> PostGenre(Genre genre)
        {
            _genreRepository.Create(genre);
            _genreRepository.Save();

            return(CreatedAtAction("GetPublisher", new { id = genre.Id }, genre));
        }
 public async Task CreateGenre(string name, string description)
 {
     Genre genre = new Genre {
         Title = name, Description = description
     };
     await genreRepository.Create(genre);
 }
        public ActionResult Create([Bind(Include = "Id,Type")] Genre genre)
        {
            if (ModelState.IsValid)
            {
                _genreRepository.Create(genre);
                return(RedirectToAction("Index"));
            }

            return(View(genre));
        }
示例#6
0
        public int Create(CreateGenreRequest request)
        {
            var genreEntity = new GenreEntity()
            {
                Description = request.Description
            };

            genreRepository.Create(genreEntity);

            return(genreEntity.Id);
        }
示例#7
0
        public async Task <GenreResponse> Create(GenreCreateRequest request)
        {
            if (await _genreRepository.IsGenreExists(request.Name))
            {
                throw new GenreAlreadyExists("Genre already exists!");
            }

            var genre = await _genreRepository.Create(_mapper.Map <Genre>(request));

            return(_mapper.Map <GenreResponse>(genre));
        }
示例#8
0
 public IActionResult Create(CategoryViewModel genre)
 {
     if (ModelState.IsValid)
     {
         var Genre = new Genre()
         {
             GenreName = genre.GenreName
         };
         var newGenre = genreRepository.Create(Genre);
         return(RedirectToAction("Index"));
     }
     return(View());
 }
示例#9
0
 public void CreateGenre(Genre newGenre)
 {
     if (Genres.FirstOrDefault(u => u.Name.Equals(newGenre.Name, StringComparison.CurrentCultureIgnoreCase)) == null)
     {
         _genreRepository.Create(newGenre);
         Genres.Add(newGenre);
     }
     else
     {
         MessageBox.Show("Такой жанр уже добавлен!", "Ошибка!");
         return;
     }
 }
示例#10
0
 public IActionResult NewGenre(Genre genre)
 {
     if (genreRepository.Find(g => g.Id.ToLower() == genre.Id.ToLower()).Any())
     {
         ModelState.AddModelError("Id", "This genre has already been created");
     }
     if (ModelState.IsValid)
     {
         genreRepository.Create(genre);
         return(RedirectToAction(nameof(Index)));
     }
     return(View(genre));
 }
示例#11
0
        public IActionResult Create(GenreVM model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            Genre genre = _mapper.Map <Genre>(model);

            _genrerepo.Create(genre);

            return(RedirectToAction(nameof(Index)));
        }
示例#12
0
        public ActionResult Create(Genre genre)
        {
            if (!ModelState.IsValid)
            {
                return(View(genre));
            }

            if (genreRepo.Create(genre))
            {
                return(RedirectToAction("Index"));
            }

            return(View("Error"));
        }
示例#13
0
        public void Initialize()
        {
            var defaultData = CreateDefaultGenre();

            foreach (var genre in defaultData)
            {
                var getGenre = _genreRepository.Get(genre.Id);
                if (getGenre.IsSuccess)
                {
                    _genreRepository.Update(genre);
                }
                else
                {
                    _genreRepository.Create(genre);
                }
            }
        }
示例#14
0
        public CreateGenreResponse CreateGenre(CreateGenreRequest request)
        {
            CreateGenreResponse response = new CreateGenreResponse();

            try
            {
                Genre genre = request.ConvertToGenre();
                _genreRepository.Create(genre);
                response.Success = true;
            }
            catch (Exception ex)
            {
                response.Success = false;
                response.Message = ex.Message;
            }
            return(response);
        }
示例#15
0
        public bool Save(Genre genre)
        {
            genre.Save();

            if (!_notification.HasNotifications())
            {
                if (genre.Id == 0)
                {
                    _genreRepository.Create(genre);
                }
                else
                {
                    _genreRepository.Update(genre);
                }
            }

            return(_notification.HasNotifications());
        }
示例#16
0
 public bool Insert(Genre genre)
 {
     _repository.Create(genre);
     return(_repository.SaveChanges());
 }
 public IActionResult AddGenre(Genre genre)
 {
     genreRepository.Create(genre);
     return(RedirectToAction("Index"));
 }
 public void CreateGenre(string name)
 {
     GenreRepository.Create(name);
 }
示例#19
0
 public void Create(GenreWithoutIdModel model)
 {
     repository.Create(model);
 }
示例#20
0
        public MappingProfile(
            IMovieRepository movieRepository,
            IGenreRepository genreRepository,
            ILanguageRepository languageRepository,
            IStyleRepository styleRepository,
            IReviewRepository reviewRepository,
            IMovieDataRepository movieDataRepository,
            IMovieDataGenreRepository movieDataGenreRepository,
            IMovieDataLanguageRepository movieDataLanguageRepository,
            IUnitOfWork unitOfWork)
        {
            string host = Environment.GetEnvironmentVariable("URL");

            CreateMap <Models.Review, Resources.Review>();
            #region Domain to Resource
            CreateMap <Models.User, Resources.User>();
            CreateMap <Models.Genre, Resources.KeyValuePair>()
            .ForMember(g => g.Id, opt => opt.MapFrom(gr => gr.IdGenre))
            .ForMember(g => g.Name, opt => opt.MapFrom(gr => gr.Name));
            CreateMap <Models.Language, Resources.KeyValuePair>()
            .ForMember(g => g.Id, opt => opt.MapFrom(gr => gr.IdLanguage))
            .ForMember(g => g.Name, opt => opt.MapFrom(gr => gr.Name));
            CreateMap <Models.Style, Resources.KeyValuePair>()
            .ForMember(g => g.Id, opt => opt.MapFrom(gr => gr.IdStyle))
            .ForMember(g => g.Name, opt => opt.MapFrom(gr => gr.Name));
            CreateMap <Models.Image, Resources.Image>()
            .ForMember(img => img.Url, opt => opt.MapFrom(img => $"{host}image/{img.Id}"));

            CreateMap <Models.Movie, Resources.Movie>()
            .ForMember(m => m.IdUser, opt => opt.MapFrom(m => m.IdUser))
            .ForMember(m => m.IdMovie, opt => opt.MapFrom(m => m.IdMovie))
            .AfterMap((movieModel, movie) =>
            {
                var data      = movieDataRepository.GetByMovieId(movieModel.IdMovie).Result;
                var genres    = new List <Resources.KeyValuePair>();
                var languages = new List <Resources.KeyValuePair>();

                movie.IdMovieData  = data.IdMovieData;
                movie.RegisterDate = data.RegisterDate;
                movie.Name         = data.Title;
                movie.Year         = data.Year;
                movieDataGenreRepository.GetAll().Result.Where(genre => genre.IdMovieData == data.IdMovieData)
                .Join(genreRepository.GetAll().Result, mdg => mdg.IdGenre, g => g.IdGenre, (mdg, g) => g)
                .ToList().ForEach(genre => {
                    genres.Add(new Resources.KeyValuePair {
                        Id = genre.IdGenre, Name = genre.Name
                    });
                });

                movieDataLanguageRepository.GetAll().Result.Where(language => language.IdMovieData == data.IdMovieData)
                .Join(languageRepository.GetAll().Result, mdl => mdl.IdLanguage, l => l.IdLanguage, (mdg, l) => l)
                .ToList().ForEach(language => {
                    languages.Add(new Resources.KeyValuePair {
                        Id = language.IdLanguage, Name = language.Name
                    });
                });
                movie.PlatFav = data.PlatFav;
                movie.Image   = new Resources.Image {
                    Id = data.ImageMongoId, Url = $"{host}image/{data.ImageMongoId}"
                };
                movie.Styles = new Resources.KeyValuePair[1]
                {
                    new Resources.KeyValuePair {
                        Id = data.IdStyle, Name = styleRepository.Get(data.IdStyle).Result.Name
                    }
                };
                movie.MetaScore      = data.MetaScore;
                movie.Imdb           = data.Imdb;
                movie.Director       = data.Director;
                movie.Popularity     = ScoreHelper.GetMoviePopularity(movie.IdMovie.Value, movieDataRepository, reviewRepository);
                movie.CommunityScore = ScoreHelper.GetMovieCommunityScore(movie.IdMovie.Value, reviewRepository);

                movie.Genres    = genres.ToArray();
                movie.Languages = languages.ToArray();
            });
            CreateMap <Models.MovieData, Resources.Movie>()
            .ForMember(m => m.Name, opt => opt.MapFrom(md => md.Title))
            .ForMember(m => m.Styles, opt => opt.MapFrom(md =>
                                                         new Resources.KeyValuePair[1] {
                new Resources.KeyValuePair {
                    Id = md.IdStyle, Name = styleRepository.GetAll().Result
                                            .FirstOrDefault(s => s.IdStyle == md.IdStyle).Name
                }
            }))
            .ForMember(m => m.Image, opt => opt.MapFrom(md =>
                                                        new Resources.Image {
                Id = md.ImageMongoId, Url = $"{host}image/{md.ImageMongoId}"
            }))
            .ForMember(m => m.CommunityScore, opt => opt.MapFrom(md => ScoreHelper.GetMovieCommunityScore(md.IdMovie, reviewRepository)))
            .ForMember(m => m.CommunityScore, opt => opt.MapFrom(md => ScoreHelper.GetMoviePopularity(md.IdMovie, movieDataRepository, reviewRepository)))
            .AfterMap((movieData, movie) =>
            {
                var genres    = new List <Resources.KeyValuePair>();
                var languages = new List <Resources.KeyValuePair>();

                movie.IdUser = movieRepository.Get(movieData.IdMovie).Result.IdUser;

                movieDataGenreRepository.GetAll().Result.Where(genre => genre.IdMovieData == movieData.IdMovieData)
                .Join(genreRepository.GetAll().Result, mdg => mdg.IdGenre, g => g.IdGenre, (mdg, g) => g)
                .ToList().ForEach(genre => {
                    genres.Add(new Resources.KeyValuePair {
                        Id = genre.IdGenre, Name = genre.Name
                    });
                });

                movieDataLanguageRepository.GetAll().Result.Where(language => language.IdMovieData == movieData.IdMovieData)
                .Join(languageRepository.GetAll().Result, mdl => mdl.IdLanguage, l => l.IdLanguage, (mdg, l) => l)
                .ToList().ForEach(language => {
                    languages.Add(new Resources.KeyValuePair {
                        Id = language.IdLanguage, Name = language.Name
                    });
                });

                movie.Genres    = genres.ToArray();
                movie.Languages = languages.ToArray();
            });
            #endregion

            #region Resource to Domain
            CreateMap <Resources.Movie, Models.Movie>()
            .ForMember(m => m.IdMovie, opt => opt.MapFrom(m => m.IdMovie))
            .ForMember(m => m.IdUser, opt => opt.MapFrom(m => m.IdUser));
            CreateMap <Resources.Movie, Models.MovieData>().BeforeMap((movie, movieData) =>
            {
                foreach (Resources.KeyValuePair genre in movie.Genres)
                {
                    if (genre.Id.Equals(null))
                    {
                        genreRepository.Create(new Models.Genre(genre.Name));
                        unitOfWork.CompleteAsync().Wait();
                    }
                }
                foreach (Resources.KeyValuePair language in movie.Languages)
                {
                    if (language.Id.Equals(null))
                    {
                        languageRepository.Create(new Models.Language(language.Name));
                        unitOfWork.CompleteAsync().Wait();
                    }
                }
            }).ForMember(m => m.ImageMongoId, opt => opt.MapFrom(m => m.Image.Id))
            .ForMember(m => m.Title, opt => opt.MapFrom(m => m.Name))
            .ForMember(m => m.IdStyle, opt => opt.MapFrom(m => m.Styles[0].Id));

            CreateMap <Resources.Image, Models.Image>()
            .ForMember(img => img.ObjectImage, opt => opt.Ignore())
            .ForMember(img => img.Id, opt => opt.MapFrom(img => img.Id));

            CreateMap <Resources.Review, Models.Review>();
            #endregion
        }
示例#21
0
 public void Create(GenreModel entity)
 {
     _genreRepository.Create(GenreMapper.ToEntity(entity));
 }
示例#22
0
 public void CreateGenre(Genre entity)
 {
     _genreRepository.Create(entity);
 }
示例#23
0
        public void Create(GenreModel entity)
        {
            var book = _mapper.Map <Genre>(entity);

            _genreRepository.Create(book);
        }