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