public async Task ApplyEditForApprovalCreatesNewMediaEdit()
{
// Arrange
var inputModel = new MediaDetailsInputModel()
{
Title = "Daa",
Overview = "fiwejfoiwejfoiwj",
Language = "en",
Id = "1",
ReleaseDate = DateTime.Now,
Runtime = 100,
Budget = 1000,
YoutubeTrailerUrl = "www.youtube.com",
Keywords = "keywords",
Genres = "Adventure, Action",
MediaType = "Movie",
PosterPath = "/yes.jpg",
};
var mock = this.GetMock <MediaEdit>(new List <MediaEdit>());
var expectedCount = 1;
var service = new MediaEditService(mock.Object);
// Act
await service.ApplyEditForApproval(inputModel, "1", "");
var newEdit = mock.Object.All().FirstOrDefault();
// Assert
Assert.Equal(expectedCount, mock.Object.All().Count());
Assert.Equal(inputModel.Title, newEdit.Title);
Assert.Equal(inputModel.Runtime, newEdit.Runtime);
Assert.Equal(inputModel.Keywords, newEdit.KeywordsJson);
Assert.Equal(inputModel.PosterPath, newEdit.PosterPath);
}
public void EditDetailsEditsModelIfIdDoesExist()
{
// Arrange
var mediaList = this.GetMedia();
var mediaRepoMock = new Mock <IRepository <Media> >();
mediaRepoMock.Setup(x => x.All())
.Returns(mediaList.AsQueryable);
mediaRepoMock.Setup(x => x.AllAsNoTracking())
.Returns(mediaList.AsQueryable);
var title = "Borat";
var expectedTitle = title + "Film";
var expectedGenre = "Adventure";
var editMediaId = mediaList.FirstOrDefault(x => x.Title == title).Id;
var expectedCount = mediaList.Count;
var mediaService = new MediaService(mediaRepoMock.Object, this.genreRepo, this.keywordRepo, this.mediaKeywordRepo);
var inputModel = new MediaDetailsInputModel()
{
Id = editMediaId,
Title = expectedTitle,
Overview = "dadadafewfwfewfwefwefwefewfwefwefwefewfwefwefweffew",
ReleaseDate = DateTime.Now,
Runtime = 100,
Budget = 100,
MediaType = "Movie",
Genres = expectedGenre,
};
// Act
Task.Run(async() =>
{
await mediaService.EditDetailsAsync(inputModel, string.Empty, string.Empty);
}).GetAwaiter().GetResult();
// Assert
Assert.Equal(expectedCount, mediaRepoMock.Object.All().Count());
Assert.Equal(expectedTitle, mediaRepoMock.Object.All().FirstOrDefault(x => x.Id == editMediaId).Title);
Assert.Equal(expectedGenre, mediaRepoMock.Object.All().FirstOrDefault(x => x.Id == editMediaId).Genres.FirstOrDefault().Genre.Name);
}
public async Task <IActionResult> Edit(MediaDetailsInputModel edit)
{
var user = await this.userManager.GetUserAsync(this.User);
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction("Edit", "Media", new { id = edit.Id }));
}
if (edit.ReleaseDateString == "01-01-0001" || edit.ReleaseDate == null)
{
this.ModelState.AddModelError(string.Empty, "Release date is required");
return(this.RedirectToAction("Edit", "Media", new { id = edit.Id }));
}
if (edit.Id == null && edit.PosterImageFile == null)
{
this.ModelState.AddModelError(string.Empty, "When you add new media you must upload poster!");
return(this.RedirectToAction("Edit", "Media", new { id = edit.Id }));
}
var isAdmin = this.User.IsInRole(GlobalConstants.AdministratorRoleName);
try
{
if (!isAdmin)
{
await this.mediaEditService.ApplyEditForApproval(edit, user.Id, this.webHostEnvironment.WebRootPath);
}
else
{
await this.mediaService.EditDetailsAsync(edit, user.Id, this.webHostEnvironment.WebRootPath);
}
}
catch (Exception ex)
{
this.ModelState.AddModelError(string.Empty, ex.Message);
return(this.RedirectToAction("Edit", "Media", new { id = edit.Id }));
}
return(this.Redirect($"/Media/{edit.MediaType}s/{edit.Id}"));
}
public async Task ApplyEditForApproval(MediaDetailsInputModel edit, string userId, string rootPath)
{
var mediaEdit = new MediaEdit()
{
Title = edit.Title,
MediaId = edit.Id,
Overview = edit.Overview,
Language = edit.Language,
IsDetailFull = true,
ReleaseDate = edit.ReleaseDate,
Runtime = edit.Runtime,
Budget = edit.Budget,
YoutubeTrailerUrl = edit.YoutubeTrailerUrl,
KeywordsJson = edit.Keywords,
Genres = edit.Genres,
CreatorId = userId,
MediaType = edit.MediaType,
};
var image = edit.PosterImageFile;
if (image != null)
{
var tempPath = GlobalConstants.TemporaryImagesDir;
var path = rootPath + tempPath;
var name = "tempPoster-" + mediaEdit.Id;
var imageExtension = await FileDownloader.DownloadImage(image, path, name);
mediaEdit.PosterPath = tempPath + $"{name}.{imageExtension}";
}
else
{
mediaEdit.PosterPath = edit.PosterPath;
}
await this.mediaEditRepo.AddAsync(mediaEdit);
await this.mediaEditRepo.SaveChangesAsync();
}
public void EditDetailsAddsModelIfIdDoesNotExists()
{
// Arrange
var mediaList = this.GetMedia();
var expectedCount = mediaList.Count + 1;
var mediaRepoMock = new Mock <IRepository <Media> >();
mediaRepoMock.Setup(x => x.All())
.Returns(mediaList.AsQueryable());
mediaRepoMock.Setup(x => x.AddAsync(It.IsAny <Media>()))
.Callback((Media model) => mediaList.Add(model));
var mediaService = new MediaService(mediaRepoMock.Object, this.genreRepo, this.keywordRepo, this.mediaKeywordRepo);
var inputModel = new MediaDetailsInputModel()
{
Title = "Film",
Overview = "dadadafewfwfewfwefwefwefewfwefwefwefewfwefwefweffew",
ReleaseDate = DateTime.Now,
Runtime = 100,
Budget = 100,
MediaType = "Movie",
Genres = "Action, Adventure",
};
// Act
Task.Run(async() =>
{
await mediaService.EditDetailsAsync(inputModel, string.Empty, string.Empty);
}).GetAwaiter().GetResult();
// Assert
Assert.Equal(expectedCount, mediaRepoMock.Object.All().Count());
Assert.True(mediaRepoMock.Object.All().Any(x => x.Title == inputModel.Title));
}
public void EditDetailsReplacesKeywordListFromInputModel()
{
// Arrange
var mediaList = this.GetMedia();
var media = mediaList[0];
var keywords = this.GetKeywords();
var mediaKeywordsList = new List <MediaKeyword>();
foreach (var keyword in keywords)
{
mediaKeywordsList.Add(new MediaKeyword()
{
Media = media, Keyword = keyword, KeywordId = keyword.Id
});
}
media.Keywords = mediaKeywordsList;
var mediaMock = new Mock <IRepository <Media> >();
var keywordsMock = new Mock <IRepository <Keyword> >();
var mediaKeywordsMock = new Mock <IRepository <MediaKeyword> >();
mediaMock.Setup(x => x.All()).Returns(mediaList.AsQueryable);
mediaMock.Setup(x => x.AddAsync(It.IsAny <Media>()))
.Callback((Media model) => mediaList.Add(model));
keywordsMock.Setup(x => x.AddAsync(It.IsAny <Keyword>()))
.Callback((Keyword model) => keywords.Add(model));
mediaKeywordsMock.Setup(x => x.Delete(It.IsAny <MediaKeyword>()))
.Callback((MediaKeyword model) => mediaKeywordsList.Remove(model));
var title = "Borat";
var expectedTitle = title + "Film";
var editMediaId = mediaList.FirstOrDefault(x => x.Title == title).Id;
var expectedCount = mediaList.Count;
var expectedGenre = "Adventure";
var mediaService = new MediaService(mediaMock.Object, this.genreRepo, keywordsMock.Object, mediaKeywordsMock.Object);
var keywordInput = this.GetKeywords().Select(x => new KeywordViewModel()
{
Value = x.Name, Id = x.Id
}).ToList();
var newKeyword = new KeywordViewModel()
{
Value = "new keyword"
};
keywordInput.Add(newKeyword);
var expectedToBeRemoved = mediaKeywordsList[0];
keywordInput.RemoveAt(0);
var serializedKeywords = JsonConvert.SerializeObject(keywordInput);
var inputModel = new MediaDetailsInputModel()
{
Id = editMediaId,
Title = expectedTitle,
Budget = 1000,
Overview = "ijweifgjwiegjweigoweg",
Runtime = 100,
ReleaseDate = DateTime.Now,
MediaType = "Movie",
Keywords = serializedKeywords,
Genres = expectedGenre,
};
// Act
Task.Run(async() =>
{
await mediaService.EditDetailsAsync(inputModel, string.Empty, string.Empty);
}).GetAwaiter().GetResult();
// Assert
Assert.False(media.Keywords.Contains(expectedToBeRemoved));
Assert.Contains(media.Keywords, x => x.Keyword.Name == newKeyword.Value);
}
public async Task <IActionResult> CommitEdit(MediaDetailsInputModel edit)
{
return(this.View());
}
public async Task EditDetailsAsync(MediaDetailsInputModel inputModel, string userId, string rootPath)
{
var media = this.mediaRepository.All()
.Include(x => x.Genres)
.ThenInclude(x => x.Genre)
.Include(x => x.Keywords)
.Include(x => x.Images)
.FirstOrDefault(x => x.Id == inputModel.Id);
bool isAdd = false;
// check if the type we try to add create exists
if (media == null)
{
isAdd = true;
string qualifiedName =
$"CinemaHub.Data.Models.{inputModel.MediaType}, CinemaHub.Data.Models, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
try
{
var type = Type.GetType(qualifiedName);
media = (Media)Activator.CreateInstance(type);
}
catch (Exception ex)
{
throw new Exception($"{inputModel.MediaType} does not exist");
}
}
// if the media exists replace all its fields, if it does not set the fields
media.Title = inputModel.Title ?? media.Title;
media.Overview = inputModel.Overview ?? media.Overview;
media.IsDetailFull = true;
media.Budget = inputModel.Budget;
media.Language = inputModel.Language ?? media.Language;
media.Runtime = inputModel.Runtime;
media.YoutubeTrailerUrl = inputModel.YoutubeTrailerUrl ?? media.YoutubeTrailerUrl;
media.ReleaseDate = inputModel.ReleaseDate;
var genres = inputModel.Genres.Split(new string[] { ", ", "&" }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
var genresDb = media.Genres.ToList();
// Remove all genres which are not in the inputModel's genres and ignore all which are
foreach (var genre in genresDb)
{
if (!genres.Contains(genre.Genre.Name))
{
media.Genres.Remove(genre);
continue;
}
genres.Remove(genre.Genre.Name);
}
// Add all the remaining genres which remained in [genres]
foreach (var genre in genres)
{
var genreDb = this.genreRepository.All().FirstOrDefault(x => x.Name == genre);
if (genreDb != null)
{
media.Genres.Add(
new MediaGenre()
{
Media = media,
Genre = genreDb,
});
}
}
// If there are no keywords everything will be removed
var keywords = inputModel.Keywords != null
? Newtonsoft.Json.JsonConvert.DeserializeObject <List <KeywordDTO> >(inputModel.Keywords)
: new List <KeywordDTO>();
var dbKeywordsIds = media.Keywords.Select(x => x.KeywordId).ToList();
// if [keyword.Id] is 0 it does not exist.
foreach (var keyword in keywords)
{
if (keyword.Id == 0)
{
var keywordDb = new Keyword()
{
Name = keyword.Value
};
await this.keywordRepository.AddAsync(keywordDb);
media.Keywords.Add(new MediaKeyword()
{
Keyword = keywordDb, Media = media,
});
continue;
}
if (!dbKeywordsIds.Contains(keyword.Id))
{
media.Keywords.Add(new MediaKeyword()
{
KeywordId = keyword.Id, Media = media,
});
}
dbKeywordsIds.Remove(keyword.Id); // Keywords which are removed from [dbKeywordsIds] won't be deleted
}
// Delete all the keywords which have remained in [dbKeywordsIds]
foreach (var id in dbKeywordsIds)
{
var mediaKeyword = media.Keywords.FirstOrDefault(x => x.KeywordId == id);
this.mediaKeywordRepository.Delete(mediaKeyword);
}
// Add/Replaces image poster
var image = inputModel.PosterImageFile;
if (image != null)
{
try
{
var mediaImage = await this.DownloadPosterImage(image, rootPath, media);
var posterImage = media.Images.FirstOrDefault(x => x.ImageType == ImageType.Poster);
if (posterImage != null)
{
media.Images.Remove(posterImage);
}
media.Images.Add(mediaImage);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
// [isAdd] is set to true if [inputModel.Id] is null (creating new media)
if (isAdd)
{
await this.mediaRepository.AddAsync(media);
}
await this.mediaRepository.SaveChangesAsync();
}
