/// <summary>
/// Returns a GenreModel for the specified Id
/// </summary>
/// <param name="id">The Id of genre to look for</param>
/// <returns></returns>
public static GenreModel GetGenreById(int id)
{
GenreModel genre = null;
var connString = ConfigurationManager.ConnectionStrings["Biblioteka.Properties.Settings.BibliotekaDBConnectionString"].ToString();
var connection = new SqlConnection(connString);
connection.Open();
var command = new SqlCommand($"SELECT * FROM Gatunki WHERE Id={id}", connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
reader.Read();
genre = new GenreModel()
{
Id = id,
Nazwa = reader.GetString(1)
};
}
}
connection.Close();
return(genre);
}
/// <summary>
/// Returns a list of all genres in the database
/// </summary>
/// <returns></returns>
public static List <GenreModel> GetAllGenres()
{
var genres = new List <GenreModel>();
var connString = ConfigurationManager.ConnectionStrings["Biblioteka.Properties.Settings.BibliotekaDBConnectionString"].ToString();
var connection = new SqlConnection(connString);
connection.Open();
var command = new SqlCommand($"SELECT * FROM Gatunki", connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var genre = new GenreModel()
{
Id = reader.GetInt32(0),
Nazwa = reader.GetString(1).Trim()
};
genres.Add(genre);
}
}
}
connection.Close();
return(genres);
}
/// <summary>
/// Returns a GenreModel for a given genre name
/// </summary>
/// <param name="name">Name of the genre to look for</param>
/// <returns></returns>
public static GenreModel GetGenreByName(string name)
{
var genre = new GenreModel();
var connString = ConfigurationManager.ConnectionStrings["Biblioteka.Properties.Settings.BibliotekaDBConnectionString"].ToString();
var connection = new SqlConnection(connString);
connection.Open();
var command = new SqlCommand($"SELECT * FROM Gatunki WHERE Genre='{name}'", connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
reader.Read();
genre.Id = reader.GetInt32(0);
genre.Nazwa = name;
}
}
connection.Close();
return(genre);
}
public async Task Save_ForSingleDeletedSongWhenDeleteCommentIsUpdated_UpdatesSongCorrectly()
{
// Arrange
var oldArtist = new ArtistModel {
Id = new ItemId("1"), Name = "Old Artist"
};
var newArtist = new ArtistModel {
Id = new ItemId("2"), Name = "New Artist"
};
var oldGenre = new GenreModel {
Id = new ItemId("1"), Name = "Old Genre"
};
var newGenre = new GenreModel {
Id = new ItemId("2"), Name = "New Genre"
};
var mocker = CreateMocker(artists: new[] { oldArtist, newArtist }, genres: new[] { oldGenre, newGenre, });
var target = mocker.CreateInstance <EditSongPropertiesViewModel>();
var song = new SongModel
{
Title = "Old Title",
TreeTitle = "Old Tree Title",
Artist = oldArtist,
Genre = oldGenre,
TrackNumber = 1,
DeleteDate = new DateTime(2021, 10, 26),
DeleteComment = "Old Delete Comment",
};
await target.Load(new[] { song }, CancellationToken.None);
// Act
target.Title = "New Title";
target.TreeTitle = "New Tree Title";
target.Artist = target.AvailableArtists.Last();
target.Genre = target.AvailableGenres.Last();
target.TrackNumber = 2;
target.DeleteComment = "New Delete Comment";
await target.Save(CancellationToken.None);
// Assert
Func <Action <SongModel>, bool> verifySongUpdate = updateAction =>
{
updateAction(song);
return(song.Title == "New Title" && song.TreeTitle == "New Tree Title" && song.TrackNumber == 2 &&
Object.ReferenceEquals(song.Artist, newArtist) && Object.ReferenceEquals(song.Genre, newGenre) &&
song.DeleteComment == "New Delete Comment");
};
var songServiceMock = mocker.GetMock <ISongsService>();
songServiceMock.Verify(x => x.UpdateSong(It.IsAny <SongModel>(), It.IsAny <Action <SongModel> >(), It.IsAny <CancellationToken>()), Times.Once);
songServiceMock.Verify(x => x.UpdateSong(song, It.Is <Action <SongModel> >(y => verifySongUpdate(y)), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task Load_ForSingleSongWithoutGenre_FillsGenreDataCorrectly()
{
// Arrange
var genre1 = new GenreModel {
Id = new ItemId("1"), Name = "Some Genre"
};
var genre2 = new GenreModel {
Id = new ItemId("2"), Name = "Another Genre"
};
var mocker = CreateMocker(genres: new[] { genre1, genre2, });
var target = mocker.CreateInstance <EditSongPropertiesViewModel>();
var song = new SongModel {
Genre = null
};
// Act
await target.Load(new[] { song }, CancellationToken.None);
// Assert
var expectedAvailableGenres = new[]
{
new EditedSongProperty <GenreModel>(null),
new EditedSongProperty <GenreModel>(genre1),
new EditedSongProperty <GenreModel>(genre2),
};
target.AvailableGenres.Should().BeEquivalentTo(expectedAvailableGenres, x => x.WithStrictOrdering());
target.Genre.Should().BeEquivalentTo(expectedAvailableGenres[0]);
}
public ActionResult AddGenre(MovieModel movieModel, GenreModel genreModel)
{
_movieServices = new MovieServices();
_movieServices.AddGenreForMovie(movieModel.Id, genreModel.Name);
return(RedirectToAction("ListMovie"));
}
public int CreateOrUpdate(GenreModel model)
{
string msgError = "";
try
{
var result = _dbHelper.ExecuteScalarSProcedureWithTransaction(out msgError, "GENRE_INSERT_OR_UPDATE",
"@id", model.Id,
"@genre_code", model.Genre_Code,
"@genre_name", model.Genre_Name,
"@sequence", model.Sequence,
"@description", model.Description,
"@active", model.Active);
if ((result != null && !string.IsNullOrEmpty(result.ToString())) || !string.IsNullOrEmpty(msgError))
{
throw new Exception(Convert.ToString(result) + msgError);
}
else
{
return(Constant.ReturnExcuteFunction.Success);
}
}
catch (Exception ex)
{
throw ex;
}
}
public List <GenreModel> GetGenres()
{
if (_albumJSON == null)
{
return(null);
}
try
{
List <GenreModel> genres = new List <GenreModel>();
foreach (var g in _albumJSON["genres"])
{
GenreModel genre = new GenreModel()
{
Genre = g.ToString()
};
genres.Add(genre);
}
return(genres);
}
catch (Exception)
{
return(null);
}
}
public async Task <IHttpActionResult> Update(GenreModel model)
{
var serviceResult = new ServiceResult <GenreModel>();
if (!ModelState.IsValid)
{
serviceResult.Success = false;
serviceResult.Error.Description = "Model is not valid.";
serviceResult.Error.Code = ErrorStatusCode.BudRequest;
return(ServiceResult(serviceResult));
}
var result = await _genreService.Update(model);
serviceResult.Success = result.Success;
if (result.Success)
{
serviceResult.Result = model;
}
else
{
serviceResult.Error = result.Error;
}
return(ServiceResult(serviceResult));
}
public async Task <IHttpActionResult> Add(GenreModel model)
{
var serviceResult = new ServiceResult <GenreModel>();
ModelState.Remove("model.Id");
if (!ModelState.IsValid)
{
serviceResult.Success = false;
serviceResult.Error.Description = "Model is not valid.";
serviceResult.Error.Code = ErrorStatusCode.BudRequest;
return(ServiceResult(serviceResult));
}
model.Id = System.Guid.NewGuid().ToString("N").Substring(0, 24);
var result = await _genreService.Add(model);
serviceResult.Success = result.Success;
if (result.Success)
{
serviceResult.Result = model;
}
else
{
serviceResult.Error = result.Error;
}
return(ServiceResult(serviceResult));
}
public void GetGenreById_Returns_OkObjectResult()
{
// Arrange
var genreRepositoryMock = new Mock <IGenreRepository>();
var genreIMapperMock = new MapperConfiguration(config =>
{
config.AddProfile(new MovieMapper());
});
var genreMapper = genreIMapperMock.CreateMapper();
var logMock = new Mock <ILogger <GenresController> >();
ILogger <GenresController> logger = logMock.Object;
GenresController genreApiController = new
GenresController(genreRepositoryMock.Object, mapper: genreMapper, logger);
var genreModel = new GenreModel()
{
Name = "Adult Content",
DateCreated = DateTime.Parse("15 May 2015"),
Id = Guid.NewGuid()
};
genreRepositoryMock.Setup(repo => repo.GetGenre(It.IsAny <Guid>()))
.Returns(genreModel);
// Act
var genreResult = genreApiController.GetGenreById(It.IsAny <Guid>());
var okResult = genreResult as OkObjectResult;
// Assert
Assert.True(okResult.StatusCode is StatusCodes.Status200OK);
}
public void DeleteGenre_Returns_NoContent()
{
// Arrange
var genreRepositoryMock = new Mock <IGenreRepository>();
var genreIMapperMock = new MapperConfiguration(config =>
{
config.AddProfile(new MovieMapper());
});
var genreMapper = genreIMapperMock.CreateMapper();
var logMock = new Mock <ILogger <GenresController> >();
ILogger <GenresController> logger = logMock.Object;
GenresController genreApiController = new
GenresController(genreRepositoryMock.Object, mapper: genreMapper, logger);
var genreModel = new GenreModel()
{
Name = "Comedy",
DateCreated = DateTime.Parse("15 May 2015"),
Id = new Guid()
};
genreRepositoryMock.Setup(repo => repo.GenreExist(It.IsAny <Guid>()))
.Returns(true);
genreRepositoryMock.Setup(repo => repo.GetGenre(It.IsAny <Guid>()))
.Returns(genreModel);
genreRepositoryMock.Setup(repo => repo.DeleteGenre(It.IsAny <GenreModel>()))
.Returns(true);
// Act
var genreResult = genreApiController.DeleteGenre(genreModel.Id);
var noContentResult = genreResult as NoContentResult;
// Assert
Assert.True(noContentResult.StatusCode is StatusCodes.Status204NoContent);
}
public IHttpActionResult CreateGenre(GenreModel model)
{
var genre = Mapper.Map <GenreModel, GenreDTO>(model);
_genreService.Create(genre);
return(Ok("Genre created"));
}
public IEnumerable <GameModel> GetGamesByGenre(GenreModel genreModel)
{
Genre genre = _unitOfWork.GenreRepository.GetById(genreModel.GenreId);
IEnumerable <Game> games = _unitOfWork.GameRepository.GetAll().Where(g => g.Genres.Contains(genre));
var gameModels = Mapper.Map <IEnumerable <GameModel> >(games);
return(gameModels);
}
public ActionResult CreateGenre(GenreModel model)
{
_facade = new DataAccessLayerfacade();
_facade.GetGenreRep().CreateGenre(new Genre {
name = model.Name
});
return(RedirectToAction("Index"));
}
public static Genre ToDomain(this GenreModel model)
{
return(new Genre
{
Id = model.Id,
Title = model.Title
});
}
public ActionResult Edit(GenreModel model)
{
var genreBO = mapper.Map <GenreBO>(model);
genreBO.Save();
return(RedirectToActionPermanent("Index", "Genre"));
}
public void Map(GenreModel from, Genre to)
{
if (to.Id != from.Id)
{
throw new ArgumentException("Cannot map. Object are not related");
}
to.Name = from.Name;
}
public async Task <GenreModel> GetGenreAsync(GenreModel genre)
{
var g = _mapper.Map <Genre>(genre);
g = await _unitOfWork.Genres.GetByIdAsync(g.GenreId);
return(_mapper.Map <GenreModel>(g));
}
public ActionResult DeleteConfirmed(int id)
{
GenreModel genremodel = db.GenreModels.Find(id);
db.GenreModels.Remove(genremodel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public GenreService()
{
foreach (var item in vs)
{
GenreModel model = new GenreModel();
model.genreName = item;
genreModelList.Add(model);
}
}
// GET: Admin/Genre
public ActionResult Index()
{
var model = new GenreModel
{
Genres = genreRepository.GetGenres()
};
return(View(model));
}
public static ServiceGenre ToServiceGenre(this GenreModel genre)
{
return(new ServiceGenre
{
ID = genre.ID,
Name = genre.Name,
ParentGenreID = genre.ParentGenreID,
});
}
public void CreateGenre(GenreModel g)
{
db.Genres.Create(new Genre()
{
NameGenre = g.NameGenre,
Genre_Books = g.Genre_Books
});
Save();
}
public void Update(GenreModel entity)
{
var index = _genreModels.FindIndex(a => a.Id == entity.Id);
if (index > 0)
{
_genreModels[index] = entity;
}
}
public async Task <GenreModel> UpdateGenreAsync(GenreModel genre)
{
var g = _mapper.Map <Genre>(genre);
g = _unitOfWork.Genres.Update(g);
await _unitOfWork.CommitAsync();
return(_mapper.Map <GenreModel>(g));
}
public IHttpActionResult EditGenre(int id, GenreModel model)
{
var genre = Mapper.Map <GenreModel, GenreDTO>(model);
genre.Id = id;
_genreService.Edit(genre);
return(Ok("Genre edited"));
}
public void UpdateGenre(GenreModel g)
{
Genre gr = db.Genres.GetItem(g.GenreId);
gr.NameGenre = g.NameGenre;
gr.Genre_Books = g.Genre_Books;
Save();
}
public async Task <bool> DeleteGenreAsync(GenreModel genre)
{
var g = _mapper.Map <Genre>(genre);
_unitOfWork.Genres.Delete(g);
var deleted = await _unitOfWork.CommitAsync();
return(deleted > 0);
}
public IEnumerable <MovieModel> GetMoviesByGenre(GenreModel genre)
{
if (genre == null)
{
throw new ArgumentNullException("Invalid genre!");
}
return(this.movieService.GetMoviesByGenre(genre));
}
public void Delete(GenreModel model)
{
_session.Delete(model);
}
public void Edit(GenreModel model)
{
var record = _session.Single<Genre>(x=>x.Id == model.Id);
record.Update(model);
_session.CommitChanges();
}
public void Add(GenreModel model)
{
_session.Add(model);
}
