public ActionResult AddAlbum(AddAlbumViewModel model, HttpPostedFileBase image = null)
{
if (ModelState.IsValid)
{
if (image != null)
{
model.ImageMimeType = image.ContentType;
model.ImageData = new byte[image.ContentLength];
image.InputStream.Read(model.ImageData, 0, image.ContentLength);
string userId = User.Identity.GetUserId();
_logger.Info("User {0} requested to add a new album", userId);
model.UniqueUserName = _userService.GetUniqueUserNameById(userId);
var album = MapperHelper.GetValue <AddAlbumViewModel, Album>(model);
_albumService.AddAlbum(album);
TempData["ResultMessage"] = string.Format(SuccessMessages.SuccessfullyCreatedAlbum, model.AlbumName);
return(RedirectToAction("ViewAlbum", new { albumName = model.AlbumName, uniqueUserName = model.UniqueUserName }));
}
else
{
ModelState.AddModelError("NoPic", "There is no photo");
}
}
return(View(model));
}
public ActionResult <Album> Post([FromBody] Album bodyAlbum)
{
var serviceResult = _albumService.AddAlbum(bodyAlbum);
if (serviceResult.ResponseCode != ResponseCode.Success)
{
return(BadRequest(serviceResult.Error));
}
var result = new Album
{
albumName = serviceResult.Result.albumName,
artistName = serviceResult.Result.artistName,
bought = serviceResult.Result.bought,
date = serviceResult.Result.date,
score = serviceResult.Result.score,
description = serviceResult.Result.description,
genre = serviceResult.Result.genre,
id = serviceResult.Result.id,
image = serviceResult.Result.image,
price = serviceResult.Result.price,
songs = serviceResult.Result.songs,
};
return(Ok(result));
}
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 IActionResult Create(AlbumCreatePostViewModel model)
{
string artist = model.Artist;
string title = model.AlbumTitle;
if (AlbumService.Exists(artist, title))
{
model.Error = string.Format(Constants.AlbumExistsError, artist, title);
return(View(model));
}
string genreDisplayName = model.Genre;
var genre = Enumerator.ToEnumOrDefault <MusicGenre>(genreDisplayName);
string coverArt = model.CoverArt;
AlbumService.AddAlbum(artist, title, genre, coverArt);
return(RedirectTo(Constants.AlbumsViewRoute));
}
public IEnumerable <string> Get()
{
//_cancionService.AddCancion(new Models.Cancion
//{
// Descripcion = "Asereje ja de je",
// Duracion = new TimeSpan(0,4,25),
// Titulo = "Aserje"
//});
//var canciones = _cancionService.GetCanciones();
//var cancion = _cancionService.GetCancion(1);
//cancion.Descripcion = "Entidad Cambiada";
//_cancionService.UpdateCancion(cancion);
//_cancionService.DeleteCancion(2);
_albumService.AddAlbum(new Models.Album
{
Nombre = "Album1"
});
_autorService.AddAutor(new Models.Autor
{
Nombre = "Jose Gomez"
});
_cancionService.AddCancion(new Models.Cancion
{
AutorId = 1,
AlbumId = 1,
Descripcion = "Cancion de mujeres",
Titulo = "Titulo1",
Duracion = new TimeSpan(0, 3, 36)
});
return(new string[] { "value1", "value2" });
}
public IActionResult Create(AlbumCreatePostViewModel model)
{
string artist = model.Artist;
string title = model.AlbumTitle;
if (AlbumService.Exists(artist, title))
{
model.Data[Constants.ErrorKey] = string.Format(
Constants.EntityExistsError, "Album", $"{artist} - {title}");
model.MusicGenres = Enumerator
.GetTextValues(typeof(MusicGenre))
.Select(displayName => new MusicGenreViewModel()
{
DisplayName = displayName
});
return(View(model));
}
var genre = Enumerator.ToEnumOrDefault <MusicGenre>(model.Genre);
AlbumService.AddAlbum(artist, title, genre, model.CoverArt);
return(RedirectTo(Constants.AlbumsViewRoute));
}
public Album AddAlbum(Album album, bool doRefresh = true)
{
_logger.Debug($"Adding album {album}");
album = AddSkyhookData(album);
// Remove any import list exclusions preventing addition
_importListExclusionService.Delete(album.ForeignAlbumId);
_importListExclusionService.Delete(album.ArtistMetadata.Value.ForeignArtistId);
// Note it's a manual addition so it's not deleted on next refresh
album.AddOptions.AddType = AlbumAddType.Manual;
// Add the artist if necessary
var dbArtist = _artistService.FindById(album.ArtistMetadata.Value.ForeignArtistId);
if (dbArtist == null)
{
var artist = album.Artist.Value;
artist.Metadata.Value.ForeignArtistId = album.ArtistMetadata.Value.ForeignArtistId;
// if adding and searching for artist, don't trigger album specific search
if (artist.AddOptions?.SearchForMissingAlbums ?? false)
{
album.AddOptions.SearchForNewAlbum = false;
}
dbArtist = _addArtistService.AddArtist(artist, false);
}
album.ArtistMetadataId = dbArtist.ArtistMetadataId;
album.Artist = dbArtist;
_albumService.AddAlbum(album, doRefresh);
return(album);
}
public ActionResult Create(AlbumModel model)
{
if (ModelState.IsValid)
{
try
{
var album = Mapper.Map <AlbumModel, AlbumDTO>(model);
album.UserId = CurrentUser.Id;
albumService.AddAlbum(album);
return(RedirectToAction("Index"));
}
catch (ArgumentNullException e)
{
ModelState.AddModelError("Error", e.Message);
}
catch (UserNotFoundException e)
{
ModelState.AddModelError("Error", e.Message);
}
}
return(PartialView(model));
}
public ActionResult <Album> PostAlbum([FromBody] Album album)
{
album.User = GetCurrentLoggedUser().Result;
_albumService.AddAlbum(album);
return(Ok(album));
}
public IActionResult Create(CreateAlbumViewModel model)
{
Boolean success = _albumService.AddAlbum(_mapper.Map <MusicCore.Album>(model.album));
return(RedirectToAction("Albums"));
}
public int Post(CreateAlbumRequest albumViewModel, CancellationToken ct)
{
return(_albumService.AddAlbum(albumViewModel, ct));
}
public ActionResult <AlbumDto> AddAlbum(AlbumDto album)
{
return(new ActionResult <AlbumDto>(
_albumService.AddAlbum(album).ToDto()));
}
public CreateResult <long> Add(AlbumInput input)
{
CheckModelState();
return(_albumService.AddAlbum(input));
}
private static void TestAlbumService()
{
List <int> list = new List <int>();
albumService = Container.Resolve <IAlbumService>();
clientService = Container.Resolve <IClientService>();
//Create
albumService.CreateAlbum(new AlbumDTO
{
Name = "The Poison",
ArtistID = artistID,
IsOfficial = true,
CreatorID = clientID,
});
albumService.CreateAlbum(new AlbumDTO
{
Name = "Venom",
ArtistID = artistID,
IsOfficial = true,
CreatorID = clientID
});
//GetAlbumIdByName
albumID = albumService.GetAlbumIdByName("The Poison");
int venomID = albumService.GetAlbumIdByName("Venom");
list.Add(albumID);
list.Add(venomID);
Console.WriteLine(list.Count() == 2 ? "ClientService - GetAlbumIdByName - OK" : "ClientService - GetAlbumIdByName - FAIL");
//GetAlbumById
AlbumDTO poison = albumService.GetAlbum(albumID);
AlbumDTO venom = albumService.GetAlbum(venomID);
Console.WriteLine(poison.Name == "The Poison" ? "AlbumService - GetAlbumById - OK" : "AlbumService - GetAlbumById - FAIL");
artistService = Container.Resolve <IArtistService>();
//AddAlbum
albumService.AddAlbum(poison);
albumService.AddAlbum(venom);
ArtistDTO artist = artistService.GetArtist(artistID);
Console.WriteLine(artist.AlbumIDs.Contains(albumID) ?
"AlbumService - AddAlbum - OK" : "AlbumService - AddAlbum - FAIL");
//GetArtistOfAlbum
ArtistDTO artist2 = albumService.GetArtistOfAlbum(albumID);
Console.WriteLine(artist2.ID == artistID ?
"AlbumService - GetArtistOfAlbum - OK" : "AlbumService - GetArtistOfAlbum - FAIL");
//TestArtistServisGetAllAlbums
Console.WriteLine(artist.AlbumIDs.Count() == 2 ?
"ArtistService - TestArtistServisGetAllAlbums - OK" : "ArtistService - TestArtistServisGetAllAlbums - FAIL");
//ListAllAlbums
var albums = albumService.ListAllAlbums(new AlbumFilter {
Name = "The Poison"
}, 1);
Console.WriteLine(albums.TotalResultCount == 2 ? "AlbumService - TestListAllAlbums - OK" : "AlbumService - TestListAllAlbums - FAIL");
//ListAllAlbumss02
var albums2 = albumService.ListAllAlbums();
Console.WriteLine(albums2.Count() == 2 ? "AlbumService - ListAllAlbumss02 - OK" : "AlbumService - ListAllAlbumss02 - FAIL");
//EditAlbum
poison.Name = "The Poisonous Poison";
albumService.EditAlbum(poison, artistID, null, null);
AlbumDTO poisonFromDB = albumService.GetAlbum(poison.ID);
Console.WriteLine(poisonFromDB.Name == "The Poisonous Poison" ? "AlbumService - TestEditAlbum - OK" : "AlbumService - TestEditAlbum - FAIL");
//DeleteAlbum
albumService.DeleteAlbum(venomID);
try
{
AlbumDTO venomFromDB = albumService.GetAlbum(venomID);
Console.WriteLine("AlbumService - TestDeleteAlbum - FAIL");
}
catch (NullReferenceException)
{
Console.WriteLine("AlbumService - TestDeleteAlbum - OK");
}
//GetCreator
ClientDTO creator = genreService.GetCreator(poison.ID);
Console.WriteLine(creator.ID == clientID ? "AlbumService - GetCreator - OK" : "AlbumService - GetCreator - FAIL");
}
public void AddAlbum(AlbumDTO albumDTO)
{
albumService.AddAlbum(albumDTO);
}
