public async Task <IActionResult> Remove(GenreViewModel genreViewModel) { if (!this.ModelState.IsValid) { return(View()); } var city = await this.genreService.GetGenre(genreViewModel.Name); if (city == null) { this.TempData["Error-Message"] = $"Genre with name {genreViewModel.Name} doesn't exist!"; return(this.RedirectToAction("Remove", "Genre")); } try { await this.genreService.DeleteGenre(genreViewModel.Name); } catch (EntityDoesntExistException e) { this.TempData["Error-Message"] = e.Message; return(this.RedirectToAction("Remove", "Genre")); } this.TempData["Success-Message"] = $"You successfully deleted genre with name {genreViewModel.Name}!"; return(this.RedirectToAction("Remove", "Genre")); }
public ActionResult UpdateGenre(int?id) { _facade = new DataAccessLayerfacade(); _model = new GenreViewModel(); _model.GetSelectedGenre = _facade.GetGenreRep().GetGenreById(id); return(View(_model)); }
//[ValidateAntiForgeryToken]//防伪造脚本攻击,CSRF public ActionResult CreateOrEdit(GenreViewModel model) { if (ModelState.IsValid) { Genre entity = new Genre { Id = model.Id, Name = model.Name, Description = model.Description }; if (model.Id != Guid.Empty) { _Service.Edit(entity); ViewBag.Message = "修改成功"; } else { entity.Id = Guid.NewGuid(); _Service.AddAndSave(entity); ViewBag.Message = "新增成功"; } return(RedirectToAction("Index")); } return(View(model)); }
public static bool FilterGenres(GenreViewModel genre, string filter) { // Trim is required here, otherwise the filter might flip on the space at the beginning (and probably at the end) string[] pieces = filter.Trim().Split(Convert.ToChar(" ")); return(pieces.All((s) => genre.GenreName.ToLower().Contains(s.ToLower()))); }
public ActionResult Update(int?id, int?relatedEntityId) { var idValue = id.GetValueOrDefault(); GenreViewModel genreViewModel = new GenreViewModel(); var genreCulture = _genreService.CulturedEntities.Include(x => x.BaseEntity) .FirstOrDefault(x => x.Id == idValue); if (relatedEntityId != null) { var selectedEntity = _genreService.CulturedEntities.Include(x => x.BaseEntity) .FirstOrDefault(x => x.Id == relatedEntityId); var genre = selectedEntity?.BaseEntity; Mapper.Map(genre, genreViewModel); Mapper.Map(genreCulture, genreViewModel); genreViewModel.RelatedEntityId = relatedEntityId.GetValueOrDefault(); genreViewModel.BaseEntityId = (genre?.Id).GetValueOrDefault(); genreViewModel.CulturedGenreSelectList = GetRelatedEntitiesList(); return(View("CreateOrUpdate", genreViewModel)); } Mapper.Map(genreCulture, genreViewModel); Mapper.Map(genreCulture.BaseEntity, genreViewModel); genreViewModel.CulturedGenreSelectList = GetRelatedEntitiesList(); return(View("CreateOrUpdate", genreViewModel)); }
public async Task <IActionResult> Preferred() { var user = await _userManager.GetUserAsync(User); //ovo valja if (user == null) { throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); } var genres = _context.Genre.AsEnumerable(); //valja if (_context.ApplicationUser.Include(u => u.PrefGenres).First(i => i.Id == user.Id).PrefGenres == null) //prefGenres = null { _context.ApplicationUser.FirstOrDefault(i => i.Id == user.Id).PrefGenres = new List <Genre>(); // u _contextu prefGenres = 0, inicijalizirala se lista _context.SaveChanges(); //ne radi } List <Genre> listPrefGenres = new List <Genre>(); listPrefGenres.AddRange(_context.ApplicationUser.Include(u => u.PrefGenres).First(i => i.Id == user.Id).PrefGenres); List <Genre> gen = new List <Genre>(); gen.AddRange(genres); // u contextu prefGenres = 0 GenreViewModel model = new GenreViewModel { PrefGenres = listPrefGenres, Genres = gen, Values = new bool[genres.Count()] }; //valja return(View(model)); // u contextu prefGenres = 3(dodani neki žanrovi, koji su kliknuti prije 50 izvođenja aplikacije, na koji način, zbilja mi nije jasno,samo odjednom count poprimi drugačiju vrijednost, a trebala bi biti nula ) }
private async Task <IList <GenreViewModel> > GetUniqueGenresAsync(IList <string> genres) { IList <GenreViewModel> uniqueGenres = new List <GenreViewModel>(); await Task.Run(() => { foreach (string genre in genres) { var newGenre = new GenreViewModel(genre); if (!uniqueGenres.Contains(newGenre)) { uniqueGenres.Add(newGenre); } } var unknownGenre = new GenreViewModel(ResourceUtils.GetString("Language_Unknown_Genre")); if (!uniqueGenres.Contains(unknownGenre)) { uniqueGenres.Add(unknownGenre); } }); return(uniqueGenres); }
public async Task <IActionResult> Add(GenreViewModel genreViewModel) { if (!this.ModelState.IsValid) { return(View()); } var city = await this.genreService.GetGenre(genreViewModel.Name); if (city != null) { this.TempData["Error-Message"] = $"Genre with name {genreViewModel.Name} already exists!"; return(this.RedirectToAction("Add", "Genre")); } try { await this.genreService.AddGenre(genreViewModel.Name); } catch (InvalidClientInputException e) { this.TempData["Error-Message"] = e.Message; return(this.RedirectToAction("Add", "Genre")); } catch (EntityAlreadyExistsException e) { this.TempData["Error-Message"] = e.Message; return(this.RedirectToAction("Add", "Genre")); } this.TempData["Success-Message"] = $"You successfully added genre with name {genreViewModel.Name}!"; return(this.RedirectToAction("Add", "Genre")); }
public async Task <IActionResult> Put(int id, [FromBody] GenreViewModel input, CancellationToken ct = default(CancellationToken)) { try { if (input == null) { return(BadRequest()); } if (await _chinookSupervisor.GetGenreByIdAsync(id, ct) == null) { return(NotFound()); } var errors = JsonConvert.SerializeObject(ModelState.Values .SelectMany(state => state.Errors) .Select(error => error.ErrorMessage)); Debug.WriteLine(errors); if (await _chinookSupervisor.UpdateGenreAsync(input, ct)) { return(Ok(input)); } return(StatusCode(500)); } catch (Exception ex) { return(StatusCode(500, ex)); } }
// GET: Mangas //public async Task<IActionResult> Index() //{ // var applicationDbContext = _context.Manga.Include(m => m.Author); // return View(await applicationDbContext.ToListAsync()); //} public async Task <IActionResult> Index(string mangaGenre, string searchString) { //System.Diagnostics.Debug.WriteLine(System.Reflection.Assembly.GetExecutingAssembly()); System.Diagnostics.Debug.WriteLine("Boom"); //LINQ IQueryable <string> genreQuery = from m in _context.Manga orderby m.ReleaseDate select m.Genre; var mangas = from m in _context.Manga select m; if (!string.IsNullOrEmpty(searchString)) { mangas = mangas.Where(s => s.Title.Contains(searchString)); } if (!string.IsNullOrEmpty(mangaGenre)) { mangas = mangas.Where(x => x.Genre == mangaGenre); } var movieGenreVM = new GenreViewModel { Genres = new SelectList(await genreQuery.Distinct().ToListAsync()), Mangas = await mangas.Include(m => m.Author).ToListAsync() }; return(View(movieGenreVM)); }
public static GenreViewModel CreateGenreViewModel(PropertyChangedEventHandler callback) { GenreViewModel genreViewModel = new GenreViewModel(); genreViewModel.PropertyChanged += callback; return(genreViewModel); }
public async Task <IActionResult> Create(GenreViewModel model) { if (!this.ModelState.IsValid) { return(View(model)); } try { if (await this.genreService.IsGenreExistAsync(model.Name)) { StatusMessage = string.Format(WebConstants.GenreAlreadyExists, model.Name); return(RedirectToAction("Create", "Genres")); } var genre = await this.genreService .CreateGenreAsync(model.Name); StatusMessage = string.Format(WebConstants.GenreSuccessfullyCreated, model.Name); return(RedirectToAction("Create", "Genres")); } catch (ArgumentException ex) { StatusMessage = ex.Message; return(RedirectToAction("Create", "Genres")); } }
public async Task <IActionResult> Edit(GenreViewModel model) { if (!ModelState.IsValid) { return(View(model)); } model.Genres = await this.genreService.GetAllGenres(); if (model.Genres.Any(x => x.Name == model.Name)) { TempData.AddErrorMessage($"Genre with name '{model.Name}' already exists !"); return(RedirectToAction(nameof(Edit))); } else { GenreServiceModel genreServiceModel = new GenreServiceModel { Id = model.Id, Name = model.Name }; await this.genreService.UpdateGenre(genreServiceModel); TempData.AddSuccessMessage($"Genre '{model.Name}' successfully updated !"); return(RedirectToAction(nameof(Add))); } }
public async Task <ActionResult> Edit(int id, GenreViewModel genre) { genre.Id = id; try { using (var client = new HttpClient()) { var token = await GetToken(); client.DefaultRequestHeaders.Add(HEADER_AUTHORIZATION, token); var serializedContent = JsonConvert.SerializeObject(genre); var stringContent = new StringContent(serializedContent, Encoding.UTF8, JSON_MEDIA_TYPE); HttpResponseMessage response = await client.PutAsync($"{genresUri}/{id}", stringContent); if (!response.IsSuccessStatusCode) { return(RedirectToAction(nameof(HomeController.Error), "Home")); } return(RedirectToAction(nameof(Index))); } } catch { return(RedirectToAction(nameof(HomeController.Error), "Home")); } }
public IHttpActionResult Post(GenreViewModel genre) { var loggedUserId = HttpContext.Current.GetOwinContext().GetUserId(); genre.UserCreated = new Models.Users.UserViewModel() { Id = loggedUserId }; genre.Datecreated = DateTimeOffset.Now; var request = new SaveGenreRequest() { RequestToken = Guid.NewGuid(), UserId = loggedUserId, Genre = genre.MapToView() }; var genresResponse = _genreService.SaveGenre(request); if (!genresResponse.Success) { return(BadRequest(genresResponse.Message)); } return(Ok(genre = genresResponse.Genre.MapToViewModel())); }
public ActionResult Add(GenreViewModel genre) { try { if (ModelState.IsValid) { Mapper.Reset(); Mapper.Initialize(cfg => cfg.CreateMap <GenreViewModel, GenreContract>()); var genreData = Mapper.Map <GenreViewModel, GenreContract>(genre); client.AddGenre(genreData); return(RedirectToAction("Index")); } else { return(View(genre)); } } catch (Exception ex) { var error = new ErrorViewModel() { ErrorMessage = ex.Message }; return(View("~/Views/Shared/Error.cshtml", error)); } }
public async Task <Genre> CreateGenre(GenreViewModel model) { if (model == null) { throw new Exception("GenreViewModel cannot be null"); } if (model.Name == null || model.Name == "") { throw new Exception("Name can not be null or empty"); } var genre = new Genre { Name = model.Name }; try { await _context.Genres.AddAsync(genre); await _context.SaveChangesAsync(); } catch (Exception ex) { throw new Exception(ex.Message); } return(genre); }
public static GenreDTO ToDTO(this GenreViewModel genreDTO) { return(new GenreDTO() { Name = genreDTO.Name, }); }
public ActionResult New(GenreViewModel genreViewModel) { if (ModelState.IsValid) { var genreDto = _mapper.Map <ExtendGenreDTO>(genreViewModel); if (!_genreService.IsUniqueEnName(genreDto)) { ModelState.AddModelError("NameEn", GlobalRes.ExistGenreName); } if (genreViewModel.NameRu != null) { if (!_genreService.IsUniqueRuName(genreDto)) { ModelState.AddModelError("NameRu", GlobalRes.ExistGenreName); } } if (ModelState.IsValid) { _genreService.AddNew(genreDto); return(RedirectToAction("GetAll")); } } var genres = _mapper.Map <IEnumerable <DelailsGenreViewModel> >(_genreService.GetAll()); genreViewModel.GenreList = new SelectList(genres, "Id", "Name"); return(View(genreViewModel)); }
public GenrePage(int genreId) { InitializeComponent(); BindingContext = vm = new GenreViewModel(); vm.ThisGenreId = genreId; vm.InitCommand.Execute(null); }
// Return Books from a specific genre public ActionResult ByGenre(string genreName, string sortBy, string searchKeyword) { var bookVMList = db.Genres.Find(genreName).Books.ToVMList(); //Search: if (!String.IsNullOrEmpty(searchKeyword)) { return(RedirectToAction("Search", new { keyword = searchKeyword, genre = genreName })); } //SortBy: if (!String.IsNullOrEmpty(sortBy)) { bookVMList = bookVMList.Sort(sortBy); } var genreVM = new GenreViewModel { ImageClass = genreName.ToLower().Substring(0, 5), Name = genreName, BookCards = bookVMList }; return(View(genreVM)); }
/// <summary> /// Initializes a new instance of the MainViewModel class. /// </summary> /// <param name="movieService">Instance of MovieService</param> /// <param name="userService">Instance of UserService</param> /// <param name="applicationService">Instance of ApplicationService</param> /// <param name="genreService">The genre service</param> public MoviePageViewModel(IMovieService movieService, IUserService userService, IApplicationService applicationService, IGenreService genreService) { _movieService = movieService; _userService = userService; ApplicationService = applicationService; GenreViewModel = new GenreViewModel(userService, genreService); RegisterMessages(); RegisterCommands(); Search = new SearchMovieViewModel(); DispatcherHelper.CheckBeginInvokeOnUI(async() => { Tabs.Add(new PopularMovieTabViewModel(ApplicationService, _movieService, _userService)); Tabs.Add(new GreatestMovieTabViewModel(ApplicationService, _movieService, _userService)); Tabs.Add(new RecentMovieTabViewModel(ApplicationService, _movieService, _userService)); Tabs.Add(new FavoritesMovieTabViewModel(ApplicationService, _movieService, _userService)); Tabs.Add(new SeenMovieTabViewModel(ApplicationService, _movieService, _userService)); SelectedTab = Tabs.First(); SelectedMoviesIndexMenuTab = 0; await GenreViewModel.LoadGenresAsync().ConfigureAwait(false); await Tabs.ToList().ParallelForEachAsync(async tab => { await tab.LoadMoviesAsync().ConfigureAwait(false); }).ConfigureAwait(false); }); }
/// <summary> /// Constructor /// </summary> /// <param name="applicationService">The application service</param> /// <param name="showService">The show service</param> /// <param name="userService">The user service</param> /// <param name="genreService">The genre service</param> public ShowPageViewModel(IApplicationService applicationService, IShowService showService, IUserService userService, IGenreService genreService) { _showService = showService; _userService = userService; _applicationService = applicationService; GenreViewModel = new GenreViewModel(userService, genreService); RegisterCommands(); RegisterMessages(); Search = new SearchShowViewModel(); DispatcherHelper.CheckBeginInvokeOnUI(async() => { Tabs.Add(new PopularShowTabViewModel(_applicationService, showService, userService)); Tabs.Add(new GreatestShowTabViewModel(_applicationService, showService, userService)); Tabs.Add(new RecentShowTabViewModel(_applicationService, showService, userService)); Tabs.Add(new FavoritesShowTabViewModel(_applicationService, showService, userService)); SelectedTab = Tabs.First(); SelectedShowsIndexMenuTab = 0; await GenreViewModel.LoadGenresAsync().ConfigureAwait(false); await Tabs.ToList().ParallelForEachAsync(async tab => { await tab.LoadShowsAsync().ConfigureAwait(false); }).ConfigureAwait(false); }); }
public async Task <ActionResult> Edit(int id, GenreViewModel genre) { genre.Id = id; try { GenresClient genresClient = new GenresClient(); var genreDto = new GenreDto { Id = genre.Id, Name = genre.Name }; await genresClient.UpdateAsync(genreDto); await genresClient.CloseAsync(); return(RedirectToAction(nameof(Index))); } catch { return(View()); } }
public ActionResult Create(int?relatedEntityId) { var genreViewModel = new GenreViewModel(Status.Active); genreViewModel.CulturedGenreSelectList = GetRelatedEntitiesList(relatedEntityId); if (relatedEntityId != null) { var selectedEntity = _genreService.CulturedEntities.Include(x => x.BaseEntity) .FirstOrDefault(x => x.Id == relatedEntityId); var config = new MapperConfiguration(cfg => { cfg.CreateMap <Genre, GenreViewModel>() .ForMember(dest => dest.Id, opt => opt.Ignore()) .ForMember(dest => dest.BaseEntityId, opt => opt.UseValue(selectedEntity?.BaseEntity.Id)) .ForMember(dest => dest.RelatedEntityId, opt => opt.UseValue(relatedEntityId)) .ForMember(dest => dest.Status, opt => opt.Ignore()); }); var mapper = config.CreateMapper(); mapper.Map(selectedEntity?.BaseEntity, genreViewModel); genreViewModel.CulturedGenreSelectList = GetRelatedEntitiesList(); return(View("CreateOrUpdate", genreViewModel)); } return(View("CreateOrUpdate", genreViewModel)); }
public IActionResult Edit(string id, [Bind("Id,Name,Color")] GenreViewModel genre) { if (id != genre.Id) { return(NotFound()); } if (ModelState.IsValid) { try { var updateGenre = _mapper.Map <GenreViewModel, GenreDTO>(genre); _service.Update(updateGenre); } catch (DbUpdateConcurrencyException) { if (!GenreExists(genre.Id)) { return(NotFound()); } throw; } catch (Exception e) { return(View("Error", new ErrorViewModel { RequestId = Request.HttpContext.TraceIdentifier, Exception = e })); } return(RedirectToAction(nameof(Index))); } return(View(genre)); }
public async Task <IActionResult> PutGenre([FromRoute] long genreId, [FromBody] GenreViewModel genreViewModel) { if (!this.ModelState.IsValid) { return(BadRequest(this.ModelState)); } if (genreId != genreViewModel.RecordId) { return(BadRequest()); } var genre = Mapper.Map <Genre>(genreViewModel); this.context.Entry(genre).State = EntityState.Modified; try { await this.context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!GenreExists(genreId)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public IActionResult OpenGenre(long?id) { if (!id.HasValue) { return(Error()); } var genre = _genreService.GetById(id.Value); if (genre == null) { return(Error()); } var subgenres = genre.Subgenres .Where(_ => !genre.Subgenres.Any(c => c.Subgenres.Contains(_))) .Select(_ => _).ToList(); var genreVM = new GenreViewModel() { Id = genre.Id, Name = genre.Name, Subgenres = genre.Subgenres }; return(View("Genre", genreVM)); }
public ActionResult Save(Genre genre) { if (!ModelState.IsValid) { var viewModel = new GenreViewModel { Genre = genre }; return(View("GenreForm", viewModel)); } if (genre.Id == 0) { _context.Genres.Add(genre); } else { var genreInDb = GetGenreById(genre.Id); genreInDb.Name = genre.Name; } _context.SaveChanges(); return(RedirectToAction("Index", "Genres")); }
public static CreateGenreRequest ConvertToCreateGenreRequest(this GenreViewModel model) { CreateGenreRequest request = new CreateGenreRequest(); request.Genre = model.Genre; return(request); }
public ActionResult Details(int id) { var model = new GenreViewModel { GenreId = id, Genre = this.Data.Genres.Find(id).Name, Games = this.Data.Games.All() .Where(g => g.Genre.Id == id) .OrderBy(g => g.Title) .Select(GameViewModel.Create) .ToList() }; return View(model); }