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);
}
