public AlbumDetailsVM(Guid userId, String userName, AlbumVM albumVM, List <PictureVM> picturesVM)
{
UserId = userId;
UserName = userName;
AlbumVM = albumVM;
PicturesVM = picturesVM;
}
public void The_Properties_Of_The_ALbum_Should_Be_The_Same()
{
AlbumVM albumVM = new AlbumVM()
{
DisplayName = "test",
ArtistsIdentities = new List <ObjectId>()
{
new ObjectId()
},
SongIdentities = new List <ObjectId>()
{
new ObjectId()
}
};
Album insertedAlbum = new Album();
_mockedAlbumRepository.Setup(x => x.Insert(It.IsAny <Album>())).Callback <Album>((insertAlbum) => insertedAlbum = insertAlbum);
_albumController.Insert(albumVM);
insertedAlbum.DisplayName.Should().Be(albumVM.DisplayName);
insertedAlbum.ArtistsIdentities.ToList()[0].Should().Be(albumVM.ArtistsIdentities.ToList()[0]);
insertedAlbum.SongIdentities.ToList()[0].Should().Be(albumVM.SongIdentities.ToList()[0]);
}
public ManageAlbumVM(UserProfileVM userProfileVM, AlbumVM albumVM, List <PictureVM> picturesVM)
{
IsUsersAlbum = userProfileVM.Id == albumVM.UserId;
UserProfileVM = userProfileVM;
AlbumVM = albumVM;
PicturesVM = picturesVM;
}
public async Task <IActionResult> AlbumDetails(Guid id)
{
ApplicationUser applicationUser = await _userManager.GetUserAsync(HttpContext.User);
Guid currentUserId = new Guid(applicationUser.Id);
if (!await _repository.ContainsUserAsync(currentUserId))
{
return(RedirectToAction("MakeNewProfile", "Main"));
}
Album album = await _repository.GetAlbumAsync(id);
if (album == null)
{
return(View("~/Views/Shared/InvalidAttempt.cshtml"));
}
album.User = await _repository.GetUserByIdAsync(album.UserId);
if (album.UserId == currentUserId)
{
return(RedirectToAction("Index", "ManageAlbum"));
}
AlbumVM albumVM = new AlbumVM(album);
List <Picture> pictures = await _repository.GetPicturesFromAlbumAsync(id);
List <PictureVM> picturesVM = new List <PictureVM>();
foreach (var picture in pictures)
{
picturesVM.Add(new PictureVM(picture));
}
AlbumDetailsVM albumDetailsVM = new AlbumDetailsVM(album.UserId, album.User.UserName, albumVM, picturesVM);
return(View(albumDetailsVM));
}
// GET: Albums/Create
public ActionResult Create()
{
AlbumVM album = new AlbumVM();
album.Producers = new SelectList(db.Producers.ToList(), "Id", "Name");
album.ArtistList = new SelectList(db.Artists.ToList(), "Id", "Name");
return(View(album));
}
public void Should_Throw_BadRequest_If_Value_Is_Null()
{
AlbumVM value = null;
var exception = Assert.Throws <HttpResponseException>(() => _albumController.Insert(value));
exception.Response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public ActionResult Create(AlbumVM model)
{
PhotoVM p = new PhotoVM();
p.AlbumID = model.id;
p.Name = "";
p.Description = "";
return(View(p));
}
public void Should_Throw_BadRequest_If_There_Is_An_Exception()
{
AlbumVM album = new AlbumVM();
_mockedAlbumRepository.Setup(x => x.Insert(It.IsAny <Album>())).Throws(new Exception());
var exception = Assert.Throws <HttpResponseException>(() => _albumController.Insert(album));
exception.Response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public ActionResult Edit(AlbumVM album)
{
if (ModelState.IsValid)
{
var userId = album.UserId;
LogicProvider.albumLogic.Update(new Album(album.AlbumId, album.Name, album.Description, userId));
return(RedirectToAction("UserPage", "User", new { id = userId }));
}
return(View());
}
public static AlbumDataModel ModelToEntity(AlbumVM model)
{
AlbumDataModel entity = new AlbumDataModel();
entity.ID = model.id;
entity.Name = model.Name;
entity.DateCreated = model.DateCreated;
entity.UserID = model.UserID;
return(entity);
}
// GET: Picture
public ActionResult Show(AlbumVM model)
{
var photos = new List <PhotoVM>();
var photosFromDB = repo.All().Where(x => x.AlbumID == model.id);
foreach (var photo in photosFromDB)
{
photos.Add(ModelMapper.EntityToModel(photo));
}
ViewBag.AlbumName = model.Name;
return(View(photos));
}
public ActionResult CreateAlbum(AlbumVM albumVM)
{
Album album = new Album();
album.Name = albumVM.Name;
album.Description = albumVM.Description;
album.Guid = Guid.NewGuid();
album.Path = MVCManager.Controller.Main.DefaultAlbumsPath;
Directory.CreateDirectory(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, album.Path, album.Guid.ToString()));
_albumRepository.Add(album);
_albumRepository.UnitOfWork.SaveChanges();
return(RedirectToAction(MVCManager.Controller.Main.Album, MVCManager.Controller.Main.Name, new { _albumRepository.GetAll().LastOrDefault().Id }));
}
public static AlbumVM EntityToModel(AlbumDataModel entity)
{
AlbumVM model = new AlbumVM();
model.id = entity.ID;
model.Name = entity.Name;
model.DateCreated = entity.DateCreated;
model.UserID = entity.UserID;
model.NoOfPhotos = entity.photos.Count;
model.User = EntityToModel(entity.User);
return(model);
}
public ActionResult Album(int?id)
{
if (id == null)
{
return(RedirectToAction(MVCManager.Controller.Main.Albums, MVCManager.Controller.Main.Name));
}
else
{
var album = _albumRepository.Get(id.GetValueOrDefault());
AlbumVM albumVM = Mapper.Map <AlbumVM>(album);
albumVM.PathAlbum = albumVM.Path + albumVM.Guid + '/';
return(View(albumVM));
}
}
public ActionResult ChangeAlbum(AlbumVM albumVM)
{
if (!string.IsNullOrWhiteSpace(albumVM.Name))
{
Album album = _albumRepository.Get(albumVM.Id);
album.Name = albumVM.Name;
album.Description = albumVM.Description;
_albumRepository.UnitOfWork.SaveChanges();
albumVM.Message = "Your changes were successfully saved!";
}
else
{
albumVM.Message = "Something wrong, Your changes were not saved!";
}
return(View(albumVM));
}
public ActionResult AlbumAsList(int?id)
{
var albums = (IList <Album>)_albumRepository.GetAll();
var album = albums.FirstOrDefault(x => x.Id == id);
if (album == null)
{
return(RedirectToAction(MVCManager.Controller.Main.Albums, MVCManager.Controller.Main.Name));
}
else
{
AlbumVM albumVM = Mapper.Map <AlbumVM>(album);
albumVM.PathAlbum = albumVM.Path + albumVM.Guid + '/';
return(View(albumVM));
}
}
public IActionResult Index()
{
//List<AlbumVM> albumList = ApiJsonHelper<AlbumVM>.GetEntityList("album/getalbums");
AlbumVM album = new AlbumVM()
{
AlbumID = 2,
ArtistName = "aaa",
ArtUrl = "ssss",
GenreName = "sadsad",
Price = 123,
Title = "asd"
};
ApiJsonHelper <AlbumVM> .PostEntity("album/AlbumPost", album);
return(View());
}
public ActionResult Create(AlbumVM model)
{
if (User.Identity.IsAuthenticated)
{
var identity = User.Identity.Name;
int?userID = Userrepo.GetID(identity);
if (userID != null)
{
model.DateCreated = DateTime.Now;
model.UserID = (int)userID;
var entity = ModelMapper.ModelToEntity(model);
repo.AddOrUpdate(entity);
}
return(RedirectToAction("Index", "Album"));
}
return(Redirect(Request.UrlReferrer.ToString()));
}
public void Should_Return_One_If_Inserted_Properly()
{
AlbumVM albumVM = new AlbumVM
{
DisplayName = "test",
ArtistsIdentities = new List <ObjectId>()
{
new ObjectId()
},
SongIdentities = new List <ObjectId>()
{
new ObjectId()
}
};
_mockedAlbumRepository.Setup(x => x.Insert(It.IsAny <Album>())).Returns(1);
_albumController.Insert(albumVM).Should().Be(1);
}
public void Should_Return_AlbumVM_Properly()
{
ObjectId id = new ObjectId();
AlbumVM albumVM = new AlbumVM
{
DisplayName = "test",
ArtistsIdentities = new List <ObjectId>()
{
new ObjectId()
},
SongIdentities = new List <ObjectId>()
{
new ObjectId()
}
};
Album album = new Album()
{
DisplayName = "test",
ArtistsIdentities = new List <ObjectId>()
{
new ObjectId()
},
SongIdentities = new List <ObjectId>()
{
new ObjectId()
}
};
_mockedAlbumRepository.Setup(x => x.GetById(id)).Returns(album);
var result = _albumController.Get(id);
result.DisplayName.Should().Be(albumVM.DisplayName);
result.Id.Should().Be(albumVM.Id);
result.ArtistsIdentities.ToList()[0].Should().Be(albumVM.ArtistsIdentities.ToList()[0]);
result.SongIdentities.ToList()[0].Should().Be(albumVM.SongIdentities.ToList()[0]);
}
public ActionResult Album(string name)
{
AlbumVM albumVM = new AlbumVM();
PhotosBL photosBL = new PhotosBL();
List <Photo> list = photosBL.GetPhotos();
albumVM.album = new List <Photo>();
foreach (Photo p in list)
{
if (p.photoalbum == name)
{
albumVM.album.Add(p);
}
}
if (albumVM.album == null)
{
return(RedirectToAction("Photos", "Home"));
}
return(View(albumVM));
}
public AlbumVM Get(ObjectId id)
{
try
{
var result = _albumRepository.GetById(id);
AlbumVM album = new AlbumVM()
{
Id = result.Id,
DisplayName = result.DisplayName,
ArtistsIdentities = result.ArtistsIdentities,
SongIdentities = result.SongIdentities
};
return(album);
}
catch
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
}
public ActionResult ViewAlbum(int?id)
{
if (id == null)
{
return(RedirectToAction("Index"));
}
AlbumVM albumToView = null;
var albumID = (int)id;
albumToView = ModelMapper.EntityToModel(repo.ByID(albumID));
if (albumToView != null)
{
return(View(albumToView));
}
return(RedirectToAction("Index"));
}
public short Insert([Microsoft.AspNetCore.Mvc.FromBody] AlbumVM value)
{
if (value == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
try
{
Album album = new Album()
{
DisplayName = value.DisplayName,
ArtistsIdentities = value.ArtistsIdentities,
SongIdentities = value.SongIdentities
};
return(_albumRepository.Insert(album));
}
catch
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
}
public async Task <IActionResult> Index(Guid id)
{
ApplicationUser applicationUser = await _userManager.GetUserAsync(HttpContext.User);
UserProfile currentUser = await _repository.GetUserByIdAsync(new Guid(applicationUser.Id));
if (currentUser == null)
{
return(RedirectToAction("MakeNewProfile", "Main"));
}
Album album = await _repository.GetAlbumAsync(id);
if (album == null)
{
return(View("~/Views/Shared/InvalidAttempt.cshtml"));
}
if (currentUser.Id != album.UserId)
{
return(RedirectToAction("AlbumDetails", "UserProfileDetails", new { id = id }));
}
List <PictureVM> picturesVM = new List <PictureVM>();
foreach (var picture in album.Pictures)
{
picturesVM.Add(new PictureVM(picture));
}
AlbumVM albumVM = new AlbumVM(album.Id, currentUser.Id, album.DateCreated, album.Description);
UserProfileVM userProfileVM = new UserProfileVM(currentUser);
ManageAlbumVM manageAlbumVM = new ManageAlbumVM(userProfileVM, albumVM, picturesVM);
return(View(manageAlbumVM));
}
public ActionResult Create(AlbumVM albums, HttpPostedFileBase CoverImage)
{
if (ModelState.IsValid)
{
Albums album = new Albums
{
Producers = db.Producers.Where(m => albums.ProducerIds.Contains(m.Id)).ToList(),
Artists = db.Artists.Where(m => albums.ArtistIds.Contains(m.Id)).ToList(),
Length = albums.Length,
Name = albums.Name,
ReleaseDate = albums.ReleaseDate,
StudioName = albums.StudioName,
CoverImagePath = "~/Images/Albums/"
};
db.Albums.Add(album);
db.SaveChanges();
album = db.Albums.OrderByDescending(m => m.id).FirstOrDefault();
if (!Directory.Exists(Server.MapPath("~/Images/Albums")))
{
Directory.CreateDirectory(Server.MapPath("~/Images/Albums"));
}
if (CoverImage.ContentLength > 0)
{
CoverImage.SaveAs(Server.MapPath("~/Images/Albums/" + album.id + ".jpg"));
}
return(RedirectToAction("Index"));
}
albums.Producers = new SelectList(db.Producers.ToList(), "Id", "Name");
albums.ArtistList = new SelectList(db.Artists.ToList(), "Id", "Name");
return(View(albums));
}
public ActionResult AlbumPage(int id)
{
var album = new AlbumVM(LogicProvider.albumLogic.GetById(id));
return(View(album));
}
public AlbumPage()
{
InitializeComponent();
BindingContext = model = new AlbumVM();
}
public ActionResult ChangeAlbum(int id)
{
AlbumVM albumVM = Mapper.Map <AlbumVM>(_albumRepository.Get(id));
return(View(albumVM));
}
