public ActionResult Create(CreateAlbumViewModel model) { string userId = User.Identity.GetUserId(); model.PhotosOfTheUser = _photoService.GetPhotosOfTheUser(userId); if (ModelState.IsValid) { Album album = new Album() { Description = model.Description, Name = model.Name, UserId = userId, }; if (!_userProfileService.CanUserAddAlbum(album.UserId)) { ModelState.AddModelError("Error", "You have reached your maximum number of free albums"); return(View(model)); } if (_albumService.IsAlbumExists(album.Name)) { ModelState.AddModelError("Error", "Album with such name already exists"); return(View(model)); } _albumService.AddAlbum(album, model.SelectedMainPhotoId); return(RedirectToAction("Index")); } return(View(model)); }
public async Task <IActionResult> Create(CreateAlbumViewModel viewModel, int id) { if (id > 0) { if (ModelState.IsValid) { List <Album> albums = _context.Albums.Where(x => x.BandID == id).ToList(); string uniqueFileName = UploadedFile(viewModel); viewModel.Album.CoverArt = uniqueFileName; viewModel.Album.BandID = id; if (!albums.Contains(viewModel.Album)) { _context.Add(viewModel.Album); //_context.Add(album); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Details), "Band", new { id })); //return RedirectToAction(nameof(Index)); } else { return(RedirectToAction(nameof(Create), "Album", new { id })); } } } viewModel.Genres = new SelectList(_context.Genres, "GenreID", "Name", viewModel.Album.GenreID); return(View(viewModel)); }
public async Task <IActionResult> CreateAlbum(CreateAlbumViewModel model) { if (!TryValidateModel(model)) { return(View(model)); } using (var memoryStream = new MemoryStream()) { try { await model.Cover.CopyToAsync(memoryStream); } catch { } var album = new Album() { Titel = model.Title, Cover = memoryStream.ToArray() }; _applicationDbContext.Albums.Add(album); _applicationDbContext.SaveChanges(); return(RedirectToAction("IndexAlbum")); } }
public IActionResult Create(CreateAlbumViewModel model) { if (int.TryParse(model.SingerId, out int singerId)) { var album = new AlbumModel() { Name = model.Name.Trim(), SingerId = singerId, CreatorId = HttpContext.Session.GetCurrentUserId() }; album = _albumAppService.Create(album); return(Json(new JsonResultEntity() { Message = "添加专辑成功!", JsonObject = Json(new AlbumViewModel() { Id = album.Id, SingerId = album.SingerId, CreatorId = album.CreatorId, Name = album.Name, SingerName = album.SingerName, CreatorName = album.CreatorName, CreationTime = album.CreationTime.ToStandardDateOfChina(), }) })); } else { throw new JMBasicException("歌唱家不存在"); } }
/// <summary> /// Redirects to the Create page in the Album folder. /// </summary> /// <returns>Rendered view to the response.</returns> public IActionResult Create() { var viewModel = new CreateAlbumViewModel(); viewModel.Genres = this.genreService.GetAll(); return(this.View(viewModel)); }
public void CallCreateServiceMethodCreateAlbumOnce_WhenInvoked() { // Arrange var createService = new Mock <ICreationService>(); var artistService = new Mock <IArtistService>(); var albumService = new Mock <IAlbumService>(); var genreService = new Mock <IGenreService>(); createService.Setup(x => x.CreateGenre(It.IsAny <string>())); var sut = new CreateController( createService.Object, artistService.Object, albumService.Object, genreService.Object); var model = new CreateAlbumViewModel() { Title = "Album Name", Artist = "Artist Name", CoverUrl = "CoverUrl" }; // Act sut.CreateAlbum(model); // Assert createService.Verify(x => x.CreateAlbum(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once); }
public async Task <IActionResult> Add() { CreateAlbumViewModel model = new CreateAlbumViewModel(); var genresResult = await _genreRepo.ListAsync(contentPublicationFlags : PublishStatus.PUBLISHED); model.Genres = genresResult.Genres.Select(g => new SelectableGenreViewModel { Name = g.Name, IsSelected = false }).ToList(); var allGroups = await _albumGroupRepo.ListAsync(); model.Groups = allGroups.Select(x => new CheckBoxListItem { Label = x.Name, Value = x.Key, IsSelected = false }).ToList(); PublishStatus flags = PublishStatus.PUBLISHED | PublishStatus.UNPUBLISHED; model.ArtistOptions = (await _artistRepo.ListNamesAsync(flags)).Select(x => new SelectListItem { Text = x.Name, Value = x.Id.ToString(), Selected = x.Id == model.ArtistId } ).ToList(); model.Tracks = new List <AlbumTrackViewModel>(); return(View(model)); }
public async Task <IActionResult> Add(CreateAlbumViewModel model) { AlbumViewModelMapper mapper = new AlbumViewModelMapper(); PublishStatus flags = PublishStatus.PUBLISHED | PublishStatus.UNPUBLISHED; var artistNames = await _artistRepo.ListNamesAsync(flags); model.ArtistOptions = artistNames .Select(x => new SelectListItem { Text = x.Name, Value = x.Id.ToString(), Selected = x.Id == model.ArtistId }).ToList(); List <CheckBoxListItem> groupOptions = (await _albumGroupRepo.ListAsync()) .Select(x => new CheckBoxListItem { Label = x.Name, Value = x.Key, IsSelected = model.Groups.Any(grp => grp.IsSelected && grp.Value == x.Key) }).ToList(); model.Groups = groupOptions; if (ModelState.IsValid) { int?createdImageId = null; if (model.CoverImage != null && model.CoverImage.Length > 0) { using (MemoryStream ms = new MemoryStream()) { await model.CoverImage.CopyToAsync(ms); ImageReferenceDetail imageRef = await _imageRepo.AddAsync(new ImageReferenceDetail { Data = ms.ToArray(), FileName = model.CoverImage.FileName, MimeType = model.CoverImage.ContentType }); if (imageRef != null) { createdImageId = imageRef.Id; } } } var result = await _albumRepo.AddAsync(mapper.Map(model, createdImageId)); await _albumGroupRepo.SetGroupsForAlbum(result.Id, model.Groups.Where(g => g.IsSelected).Select(g => g.Value).ToList()); this.SetBootstrapPageAlert("Success", "Album added", BootstrapAlertType.success); return(RedirectToAction(nameof(Index))); } else { return(View(model)); } }
public async Task CreateAsync(CreateAlbumViewModel viewModel) { var album = this._mapper.Map <Album>(viewModel); await this._unitOfWork.Albums.AddAsync(album); await this._unitOfWork.SaveChangesAsync(); }
public IActionResult Create(CreateAlbumViewModel viewModel) { var user = (User)this.userService.GetUser(this.Identity.Username, this.Identity.Password); this.albumService.AddAlbum(viewModel, user); return(this.All()); }
public async Task <IActionResult> Create(CreateAlbumViewModel model, List <IFormFile> Files) { var currentUser = userManager.GetUserAsync(User).Result; if (ModelState.IsValid) { var album = new Album() { Name = model.Name, Description = model.Description, CreatedOn = DateTime.UtcNow, User = currentUser, Category = model.Category }; db.Album.Add(album); db.SaveChanges(); if (Files.Capacity > 0) { foreach (var image in Files) { string filename = image.FileName.Split('\\').Last(); var img = new Image() { Name = filename, Album = album, User = currentUser }; db.Images.Add(img); string path = Path.Combine(environment.WebRootPath, "uploads", currentUser.Id, album.Id.ToString()); Directory.CreateDirectory(Path.Combine(path)); using (FileStream fs = new FileStream(Path.Combine(path, filename), FileMode.Create)) { await image.CopyToAsync(fs); } currentUser.ImagesCount++; } currentUser.AlbumsCount++; } db.Update(currentUser); db.SaveChanges(); return(RedirectToAction("Index", "MyProfile")); } return(RedirectToAction("Index", "MyProfile")); }
public ActionResult Create() { CreateAlbumViewModel model = new CreateAlbumViewModel(); UserDto user = (UserDto)Session["user"]; model.Privacy = new Models.PrivacyViewModel(); model.Privacy.Level = PrivacyLevel.Public; model.Privacy.GroupNames = user.Groups.Select(g => new SelectListItem() { Text = g.Name, Value = g.Id.ToString(), Selected = false }); return View(model); }
// GET: Albums/Create public ActionResult Create() { string userId = User.Identity.GetUserId(); CreateAlbumViewModel createAlbumViewModel = new CreateAlbumViewModel { PhotosOfTheUser = _photoService.GetPhotosOfTheUser(userId) }; return(View(createAlbumViewModel)); }
// GET: /Admin/Album/Create public ActionResult Create() { var model = new CreateAlbumViewModel { GenreLookupList = _genreService.GetAllGenres().Genres.OrderBy(g => g.Name), ArtistLookupList = _artistService.GetAllArtists().Artists.OrderBy(a => a.Name) }; return(View(model)); }
public void AddAlbum(CreateAlbumViewModel albumView) { Album album = Mapper.Map <CreateAlbumViewModel, Album>(albumView); album.AlbumImage.ImageData = GetArray(albumView.AlbumImage); album.Singer = singerDomainService.GetSingerById(albumView.SingerId); albumDomainService.Entry(album).State = EntityState.Added; albumDomainService.SaveChanges(); }
public virtual ActionResult CreateAlbum(CreateAlbumViewModel albumView) { if (ModelState.IsValid) { adminAlbum.AddAlbum(albumView); return(Redirect(Url.Action(MVC.Admin.AdminAlbum.FormAlbumSuccess()))); } return(PartialView("FormCreateAlbum", adminAlbum.GetCreateAlbumViewModel(albumView))); }
public ActionResult CreateAlbum(CreateAlbumViewModel album) { if (!ModelState.IsValid) { return(View()); } if (GalleryService.CreateAlbum(album.ToEntity())) { return(RedirectToAction("Index", "Gallery")); } return(View()); }
public ActionResult SaveAlbum(CreateAlbumViewModel newAlbum) { string currentUserId = User.Identity.GetUserId(); if (ModelState.IsValid) { FacebookDatabaseEntities db = new FacebookDatabaseEntities(); newAlbum.saveToDatabase(currentUserId, Server, db); } char[] idArgument = currentUserId.ToCharArray(); return(RedirectToAction("Show", "Profile", new { id = currentUserId })); }
public void CreateAlbum(CreateAlbumViewModel model) { var album = new Album() { Name = model.Name, Cover = model.Cover, }; this.db.Albums.Add(album); this.db.SaveChanges(); }
public HttpResponse Create(CreateAlbumViewModel model) { var errors = this.validatorService.AlbumValidator(model); if (errors.Any()) { return(this.View()); } this.albumService.CreateAlbum(model); return(this.Redirect("/Albums/All")); }
public ActionResult Create(CreateAlbumViewModel model) { if (!ModelState.IsValid) { model.GenreLookupList = _genreService.GetAllGenres().Genres.OrderBy(g => g.Name); model.ArtistLookupList = _artistService.GetAllArtists().Artists.OrderBy(a => a.Name); return(View(model)); } _albumService.CreateAlbum(model.ConvertToCreateAlbumRequest()); return(RedirectToAction("Index")); }
public IActionResult Create(int?id) { CreateAlbumViewModel viewModel = new CreateAlbumViewModel(); viewModel.Band = _context.Bands.FirstOrDefault(x => x.BandID == id); viewModel.Album = new Album(); viewModel.Album.ReleaseDate = DateTime.Now; viewModel.Genres = new SelectList(_context.Genres, "GenreID", "Name"); viewModel.Bands = new SelectList(_context.Bands, "BandID", "Name", viewModel.Band.BandID); return(View(viewModel)); }
public IActionResult OnGet() { ArtistList = _context.Artists .OrderBy(x => x.Name) .Select(x => new SelectListItem { Text = x.Name, Value = x.ArtistId.ToString() }); Album = new CreateAlbumViewModel(); return(Page()); }
public ActionResult CreateAlbum() { var artistNames = this.artistService .GetArtists() .Select(x => x.Name) .OrderBy(x => x) .ToList(); var model = new CreateAlbumViewModel() { AllArtists = artistNames }; return(View(model)); }
public IActionResult Create([FromBody] CreateAlbumViewModel album) { IActionResult _result = new ObjectResult(false); GenericResult _registrationResult = null; try { if (ModelState.IsValid) { AlbumService _albumService = new AlbumService(_albumRepository, _userRepository); Album _album = _albumService.CreateAlbum(album.Title, album.Description, album.Username); if (_album != null) { _registrationResult = new GenericResult() { Succeeded = true, Message = "Create Album succeeded" }; } } else { _registrationResult = new GenericResult() { Succeeded = false, Message = "Invalid fields." }; } } catch (Exception ex) { _registrationResult = new GenericResult() { Succeeded = false, Message = ex.Message }; _loggingRepository.Add(new Error() { Message = ex.Message, StackTrace = ex.StackTrace, DateCreated = DateTime.Now }); _loggingRepository.Commit(); } _result = new ObjectResult(_registrationResult); return(_result); }
public void AddAlbum(CreateAlbumViewModel viewModel, User user) { var album = new Album() { Name = viewModel.Name, Cover = viewModel.Cover, UserId = user.Id }; this.dbContext .Albums .Add(album); this.dbContext .SaveChanges(); }
private string UploadedFile(CreateAlbumViewModel model) { string uniqueFileName = null; if (model.CoverArtImage != null) { string uploadsFolder = Path.Combine(webHostEnvironment.WebRootPath, "images"); uniqueFileName = Guid.NewGuid().ToString() + "_" + model.CoverArtImage.FileName; string filePath = Path.Combine(uploadsFolder, uniqueFileName); using (var fileStream = new FileStream(filePath, FileMode.Create)) { model.CoverArtImage.CopyTo(fileStream); } } return(uniqueFileName); }
public async Task <IActionResult> CreateAlbum(CreateAlbumViewModel albumView) { if (!this.ModelState.IsValid) { return(this.View(albumView)); } var success = await this.songService.CreateAlbumAsync(albumView.Album); if (success) { return(this.RedirectToAction("Index", "SongsAdmin")); } return(this.BadRequest()); }
public HttpResponse Create(CreateAlbumViewModel model) { if (!User.IsAuthenticated) { return(Redirect("Users/Login")); } var checkForErrors = AlbumsService.CreateAlbum(model); if (checkForErrors.Count != 0) { return(Error(checkForErrors)); } return(Redirect("/Albums/All")); }
public async Task <IActionResult> Edit(int id, CreateAlbumViewModel viewModel) { if (id != viewModel.Album.AlbumID) { return(NotFound()); } if (ModelState.IsValid) { try { string uniqueFileName = UploadedFile(viewModel); if (uniqueFileName == null) { _context.Entry(viewModel.Album).State = EntityState.Modified; _context.Update(viewModel.Album); _context.Entry(viewModel.Album).Property(x => x.CoverArt).IsModified = false; } else { viewModel.Album.CoverArt = uniqueFileName; _context.Update(viewModel.Album); } await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AlbumExists(viewModel.Album.AlbumID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Details), "Album", new { id })); //return RedirectToAction(nameof(Index)); } viewModel.Genres = new SelectList(_context.Genres, "GenreID", "Name", viewModel.Album.GenreID); viewModel.Bands = new SelectList(_context.Bands, "BandID", "Name", viewModel.Album.BandID); return(View(viewModel)); }
public async Task <IActionResult> CreateAlbum(CreateAlbumViewModel model) { if (!ModelState.IsValid) { return(View(model)); } Album newAlbum = new Album { countOfTrecks = 0, Rate = 0, Name = model.Name, //UserProfile = _userManager.GetUserId() }; return(RedirectToAction("Index", "Home")); }
public ActionResult Create(CreateAlbumViewModel model) { UserDto user = (UserDto)Session["user"]; bus.Send(new CreateAlbum() { Id = Guid.NewGuid(), Description = model.Description, Title = model.Title, UserId = user.Id, Privacy = new Privacy() { OwnerId = user.Id, VisibleToGroups = model.Privacy.SelectedGroups, Published = model.Privacy.Publish, OnlyForLoggedInUsers = model.Privacy.OnlyLoggedInUsers, Level = model.Privacy.Level }, Bus = bus }); return RedirectToAction("Albums", "User", new { username = user.Username }); }