public ActionResult Create(NewAlbumViewModel model)
{
if (!ModelState.IsValid)
{
TempData["result"] = ErrorMsg;
return(RedirectToAction("_Albums"));
}
try
{
var album = _mapper.Map <Album>(model);
album.DateCreated = DateTime.UtcNow;
if (GetUserId() != null)
{
album.UserId = GetUserId();
}
_albumRepository.Insert(album);
_unitOfWork.Save();
TempData["result"] = $"Album {model.AlbumTitle} has been added.";
}
catch (Exception e)
{
TempData["result"] = ErrorMsg + e.Message;
}
return(RedirectToAction("_Albums"));
}
public void AddAlbum(NewAlbumViewModel newAlbum)
{
if (newAlbum.ArtistId == null && string.IsNullOrEmpty(newAlbum.ArtistName))
{
throw new Exception("Artist has to be specified!");
}
var albumToDb = new Album()
{
Name = newAlbum.Name,
Year = newAlbum.Year,
Duration = newAlbum.Duration,
StyleId = newAlbum.StyleId,
IsDeleted = false,
DateAdded = DateTime.Now
};
if (newAlbum.ArtistId != null)
{
albumToDb.ArtistId = (int)newAlbum.ArtistId;
}
else
{
var newArtist = new Artist()
{
Name = newAlbum.ArtistName
};
albumToDb.Artist = newArtist;
}
_db.Albums.Add(albumToDb);
_db.SaveChanges();
}
public void UpdateAlbum(int id, NewAlbumViewModel model)
{
var album = Find(id);
Mapper.Map(model, album);
_tagsService.UpdateAlbumWithTags(album, model.Tags);
_context.SaveChanges();
}
public static AlbumEntity FromNewAlbumViewModel(NewAlbumViewModel albumViewModel)
{
var albumEntity = new AlbumEntityCreator(albumViewModel).CreateAlbumEntity();
albumEntity.Photos = ExtractPhotos(albumViewModel, albumEntity.Place);
return(albumEntity);
}
public void CreatePostActionRepoReceivedInsertCallAndUnitOfWorkSaveCall()
{
var album = new NewAlbumViewModel();
_albumsController.Create(album);
_albumRepository.Received().Insert(Arg.Any <Album>());
_unitOfWork.Received().Save();
}
public async Task<IActionResult> NewAlbum(NewAlbumViewModel model)
{
ViewData["Message"] = "Created";
if (ModelState.IsValid)
{
return View("Items");
}
return View(model);
}
public ActionResult Create()
{
var model = new NewAlbumViewModel()
{
Public = true
};
return(PartialView(model));
}
public void CreatePostActionDoesNotCreateAlbumWhenHasModelError()
{
var album = new NewAlbumViewModel();
_albumsController.ModelState.AddModelError("Title", "NewErrorMsg");
_albumsController.Create(album);
_albumRepository.DidNotReceive().Insert(Arg.Any <Album>());
_unitOfWork.DidNotReceive().Save();
}
public ActionResult EditConfirm(int id, NewAlbumViewModel model)
{
if (!ModelState.IsValid)
{
ViewBag.Message = _helperService.ModelErrorsToString(ModelState);
return(Edit(id));
}
_albumsService.UpdateAlbum(id, model);
return(RedirectToAction("Details", new { Id = id }));
}
public ActionResult Create()
{
DateTime now = DateTime.Now;
var newAlbumViewModel = new NewAlbumViewModel
{
From = now,
To = now
};
return(View(newAlbumViewModel));
}
public ActionResult AddConfirmed(NewAlbumViewModel model)
{
if (!ModelState.IsValid)
{
ViewBag.Message = _helperService.ModelErrorsToString(ModelState);
return(Add());
}
var id = _albumsService.AddAlbum(model);
return(RedirectToAction("Details", new { Id = id }));
}
public async Task <IActionResult> NewAlbum(NewAlbumViewModel obj)
{
Album model = obj.Album;
//IF model state is valid then procced
if (ModelState.IsValid)
{
if (model.Id == 0)
{
model.CreatedDate = DateTime.Now.ToString();
}
AccountUser user = await GetLoggedInUser();
model.AccountUserId = user.Id;
if (model.FileLists?.Count > 0)
{
string FileExtension = String.Empty;
//CREATE album with valid images or gives an ERROR
if (!ValidateFileExtension(model.FileLists, out FileExtension))
{
TempData["Error"] = "File Extension " + FileExtension + " is not allowed";
toastNotification.AddErrorToastMessage("File Extension " + FileExtension + " is not allowed");
return(RedirectToAction("NewAlbum"));
}
List <Photos> p = new List <Photos>();
List <string> Paths = new List <string>();
Paths = await LMCommon.UploadMultiplePhoto(model.FileLists, hostingEnvironment.WebRootPath, configuration["PhotoPath"]);
if (Paths.Count > 0)
{
foreach (var item in Paths)
{
Photos ph = new Photos();
ph.PhotoPath = item;
ph.UserId = user.Id;
ph.ImgName = GetImageName(item);
ph.UplodedDate = DateTime.Now.ToString();
p.Add(ph);
}
}
model.PhotoList = p;
}
albumRepository.Add(model);
toastNotification.AddSuccessToastMessage("Album save successfully");
}
return(RedirectToAction("NewAlbum"));
}
public ActionResult Create([Bind(Include = "Title, Description, Place, City, Country, From, To, Photos")]
NewAlbumViewModel newAlbumViewModel)
{
if (ModelState.IsValid)
{
var aAlbum = newAlbumViewModel.ToAlbumEntity();
_albumRepository.AddAlbum(aAlbum);
return(RedirectToAction("Index"));
}
newAlbumViewModel.Photos = null;
return(View(newAlbumViewModel));
}
public int AddAlbum(NewAlbumViewModel model)
{
var artist = _context.Artists.Find(model.AuthorId);
if (artist == null)
{
throw new NotFoundException();
}
artist.AlbumCount += 1;
var album = Mapper.Map <Album>(model);
album.Tags = new List <Tag>();
_tagsService.UpdateAlbumWithTags(album, model.Tags);
_context.Albums.Add(album);
_context.SaveChanges();
return(album.Id);
}
/// <summary>
/// NEW ALBUM view
/// </summary>
/// <returns>view</returns>
public async Task <IActionResult> NewAlbum()
{
if (TempData["Error"] != null)
{
ViewBag.Error = TempData["Error"].ToString();
}
NewAlbumViewModel model = new NewAlbumViewModel();
AccountUser user = await GetLoggedInUser();
model.AlbumList = albumRepository.GetUserAlbums(user.Id);
model.AlbumList.Select(p => { p.ProtectorId = Protector.Protect(p.Id.ToString()); return(p); }).ToList();
model.Album = new Album();
return(View(model));
}
public void TestCreatePost_GivenFilledNewNiewModel_Should_CreateAndSaveNewAlbum()
{
TestContext testContext = new TestContextBuilder().Build();
var albumController = new AlbumController(testContext.AlbumRepository, testContext.PhotoRepository, null);
var newAlbumViewModel = new NewAlbumViewModel
{
Id = 1,
Title = $"Title1",
Description = "Description1",
From = DateTime.Now, To = DateTime.Now,
Place = "Place1", City = "City1", Country = "Country1",
Photos = new HttpFile[0]
};
var result = albumController.Create(newAlbumViewModel) as RedirectToRouteResult;
Assert.NotNull(result);
Assert.AreEqual(result.RouteValues["action"], "Index");
Assert.IsTrue(testContext.Context.Albums.Count() == 1);
}
public ActionResult NewAlbum(HttpPostedFileBase file, FormCollection form)
{
var model = new NewAlbumViewModel();
bool success = false;
var album = new Album();
if (form != null)
{
album.AlbumTitle = form["title"].ToString();
album.Year = !string.IsNullOrEmpty(form["year"].ToString()) ? Convert.ToInt32(form["year"].ToString()) : Convert.ToInt32("2017");
album.Directory = HelperFunctions.MakeValidDirectoryName(album.AlbumTitle);
if (!HelperFunctions.CheckIfAlbumExists(album.AlbumTitle))
{
success = HelperFunctions.InsertNewAlbum(album);
}
else
{
model.ErrorMessage = "Album Name already exists. Try adding the year after it.";
}
}
if (success)
{
HelperFunctions.CreateS3Folder(album.Directory);
if (file != null)
{
HttpPostedFileBase image = file;
HelperFunctions.UploadImage(image, "", "Dashboard", string.Concat(album.Directory, ".jpg"));
}
}
if ((string)Session["ValidSession"] == "valid" && success)
{
return(View());
}
else
{
return(View("~/Views/Home/Index.cshtml", new DashboardViewModel()));
}
}
public static AlbumEntity ToAlbumEntity(this NewAlbumViewModel albumViewModel)
{
return(AlbumEntityCreator.FromNewAlbumViewModel(albumViewModel));
}
private static ICollection <PhotoEntity> ExtractPhotos(NewAlbumViewModel albumViewModel, PlaceEntity placeEntity)
{
return(albumViewModel.Photos.Select(httpFile => CreatePhoto(httpFile, placeEntity)).ToList());
}
public IHttpActionResult AddAlbum(NewAlbumViewModel album)
{
_service.AddAlbum(album);
return(Ok());
}
