public async Task Update_Genre_Should_Persiste()
{
using (var factory = new MusicStoreContextFactory())
{
int genreId = 0;
using (var context = factory.CreateMusicStoreContext())
{
var genre = new GenreEntity
{
Name = "Name"
};
context.Genres.Add(genre);
context.SaveChanges();
genreId = genre.Id;
}
using (var context = factory.CreateMusicStoreContext())
{
var genreForUpdateDto = new GenreForUpdatingDto
{
Id = genreId,
Name = "Updated"
};
var unitOfWork = new UnitOfWork(context, _mapper);
await unitOfWork.Genres.UpdateAsync(genreForUpdateDto);
await unitOfWork.SaveAsync();
}
using (var context = factory.CreateMusicStoreContext())
{
var genre = context.Genres.First();
Assert.Equal("Updated", genre.Name);
}
}
}
public bool SaveGenre(Genre genre)
{
bool result = false;
ISession session = SessionFactory.GetSession();
ITransaction tx = session.BeginTransaction();
try
{
EntityConverter converter = new EntityConverter();
GenreEntity dataEntity = converter.FromBusinessEntity(genre);
session.SaveOrUpdate(dataEntity);
tx.Commit();
genre.ID = dataEntity.ID;
result = true;
}
catch (Exception ex)
{
Logger.Write(ex);
tx.Rollback();
}
finally
{
session.Close();
tx.Dispose();
}
return(result);
}
public string createGenre(GenreEntity genreEntity)
{
using (var scope = new TransactionScope())
{
if (genreEntity != null)
{
if (!_uow.GenreRepository.Exists(genreEntity.genreStyle))
{
var genre = GenreMapperInitializer(genreEntity);
_uow.GenreRepository.Insert(genre);
if (genreEntity.GenreMovies != null)
{
var genreMovies = GenreMovieMapperInitializer(genreEntity);
_uow.GenreMovieRepository.InsertBatch(genreMovies);
}
_uow.Commit();
scope.Complete();
return(genre.genreStyle);
}
else
{
return("genres exist");
}
}
return("-1");
}
}
public async Task Delete_Album_Should_Persiste()
{
using (var factory = new MusicStoreContextFactory())
{
int genreId = 0;
using (var context = factory.CreateMusicStoreContext())
{
context.Database.EnsureCreated();
var genre = new GenreEntity
{
Name = "Name"
};
context.Genres.Add(genre);
context.SaveChanges();
genreId = genre.Id;
}
using (var context = factory.CreateMusicStoreContext())
{
var unitOfWork = new UnitOfWork(context, _mapper);
await unitOfWork.Genres.DeleteAsync(genreId);
await unitOfWork.SaveAsync();
}
using (var context = factory.CreateMusicStoreContext())
{
var genre = context.Genres.FirstOrDefault();
Assert.Null(genre);
}
}
}
public IPagedList <Genre> GetGenres(ILoadOptions options)
{
IPagedList <Genre> result = new PagedList <Genre>();
if (options == null)
{
return(result);
}
if (options.MaxResults <= 0)
{
return(result);
}
ISession session = SessionFactory.GetSession();
try
{
DetachedCriteria countCriteria = GetGenresImpl(options);
DetachedCriteria listCriteria = GetGenresImpl(options);
countCriteria.SetProjection(Projections.RowCount());
countCriteria.ClearOrders();
listCriteria.
SetFirstResult(options.FirstResult).
SetMaxResults(options.MaxResults);
IMultiCriteria multiCriteria = session.CreateMultiCriteria();
multiCriteria.Add(countCriteria);
multiCriteria.Add(listCriteria);
IList queryResult = multiCriteria.List();
result.TotalItems = (int)((IList)queryResult[0])[0];
IList recordsList = (IList)queryResult[1];
EntityConverter entityConverter = new EntityConverter();
foreach (var e in recordsList)
{
GenreEntity dataEntity = e as GenreEntity;
Genre businessEntity = entityConverter.FromDataEntity(dataEntity);
result.Add(businessEntity);
}
}
catch (Exception ex)
{
Logger.Write(ex);
}
finally
{
session.Close();
}
return(result);
}
public void AddGenre(GenreEntity genre)
{
if (genre is null)
{
throw new ArgumentNullException(nameof(genre));
}
m_Context.Genres.Add(genre);
}
public static GenreModel ToModel(this GenreEntity artist)
{
return(new GenreModel
{
Id = artist.Id.ToItemId(),
Name = artist.Name,
});
}
public void DeleteGenre(GenreEntity genre)
{
if (genre is null)
{
throw new ArgumentNullException(nameof(genre));
}
m_Context.Genres.Remove(genre);
}
public static bool AddGenreBL(GenreEntity newGenre)
{
bool genreAdded = false;
if (ValidateGenre(newGenre))
{
GenreDAL genreDAL = new GenreDAL();
genreAdded = genreDAL.AddGenreDAL(newGenre);
}
return(genreAdded);
}
public int Create(CreateGenreRequest request)
{
var genreEntity = new GenreEntity()
{
Description = request.Description
};
genreRepository.Create(genreEntity);
return(genreEntity.Id);
}
private async Task <GenreEntity> PostGenre()
{
var genre = new GenreEntity
{
Name = "Adventure"
};
var postResponse = (ObjectResult)await _genreController.Post(genre);
var genreResponse = (GenreEntity)postResponse.Value;
return(genreResponse);
}
public ActionResult <GenreEntity> PostGenreEntity(GenreCreateDto genreEntity)
{
GenreEntity toAdd = _mapper.Map <GenreEntity>(genreEntity);
_repository.Add(toAdd);
if (!_repository.Save())
{
throw new Exception("Failed on save");
}
return(CreatedAtAction(nameof(GetGenreEntity), toAdd));
}
private static bool ValidateGenre(GenreEntity genre)
{
StringBuilder sd = new StringBuilder();
bool validGenre = true;
if (genre.GenreName == string.Empty)
{
validGenre = false;
sd.Append(Environment.NewLine + "Genre Name required");
}
return(validGenre);
}
public void Create(GenreEntity model)
{
var sql = $"INSERT INTO Genres (Description) OUTPUT INSERTED.Id VALUES ('{model.Description}');";
using (SqlConnection connection = new SqlConnection(_connectionString))
{
connection.Open();
var insertedId = (int)connection.ExecuteScalar(sql);
connection.Close();
model.Id = insertedId;
};
}
public static GenreModel ToModel(GenreEntity genreEntity)
{
if (genreEntity == null)
{
return(null);
}
return(new GenreModel
{
Description = genreEntity.Description,
Id = genreEntity.Id,
Name = genreEntity.Name
});
}
public void SeedGenres(MoviesContext context)
{
if (context.Genres.Any())
{
return;
}
var comedyGenreEntity = new GenreEntity()
{
Name = "Comedy",
};
var actionGenreEntity = new GenreEntity()
{
Name = "Action",
};
var scifiGenreEntity = new GenreEntity()
{
Name = "Sci-fi",
};
var dramaGenreEntity = new GenreEntity()
{
Name = "Drama",
};
var crimeGenreEntity = new GenreEntity()
{
Name = "Crime",
};
context.Genres.AddRange(new GenreEntity[]
{
comedyGenreEntity,
actionGenreEntity,
scifiGenreEntity,
dramaGenreEntity,
crimeGenreEntity
});
context.SaveChanges();
_roles.Add(comedyGenreEntity.Id, comedyGenreEntity);
_roles.Add(actionGenreEntity.Id, actionGenreEntity);
_roles.Add(scifiGenreEntity.Id, scifiGenreEntity);
_roles.Add(dramaGenreEntity.Id, dramaGenreEntity);
_roles.Add(crimeGenreEntity.Id, crimeGenreEntity);
}
public async Task UpsertAsync(GenreEntity genre)
{
var inode = database.GetNodes(genre.EntityId, genre.GetType().Name);
if (inode.Count == 0)
{
var node = mapper.Map <Node>(genre);
database.AddNode(node);
}
else
{
var node = mapper.Map <Node>(genre);
database.UpdateNode(node);
}
}
public GenreEntity SearchGenre(int genreId)
{
var ObjContext = new CinestarEntitiesDAL();
Genre ObjLang = ObjContext.Genres.Find(genreId);
GenreEntity genre = new GenreEntity();
if (ObjLang != null)
{
genre.GenreId = ObjLang.GenreId;
genre.GenreName = ObjLang.GenreName;
}
return(genre);
}
public async Task <GenreDTO> CreateGenreAsync(CreateGenreDTO createGenreDTO)
{
var genre = new GenreEntity
{
Name = createGenreDTO.Name
};
await _DBContext.Genres.AddAsync(genre);
await _DBContext.SaveChangesAsync();
var genreDTO = _mapper.Map <GenreDTO>(genre);
return(genreDTO);
}
public ActionResult CreateGenre(GenreEntity genre)
{
bool isAdded = false;
if (ModelState.IsValid)
{
isAdded = GenreBL.AddGenreBL(genre);
if (isAdded)
{
return(RedirectToAction("IndexGenre"));
}
}
return(View(genre));
}
public List <GenreEntity> ViewAllGenreDAL()
{
List <GenreEntity> objGenreList = new List <GenreEntity>();
var objcontext = new CinestarEntitiesDAL();
var query = from s in objcontext.Genres
select s;
GenreEntity objGenre = null;
foreach (var newGenre in query)
{
objGenre = new GenreEntity();
objGenre.GenreId = newGenre.GenreId;
objGenre.GenreName = newGenre.GenreName;
objGenreList.Add(objGenre);
}
return(objGenreList);
}
public GenreEntity FromBusinessEntity(Genre businessEntity)
{
if (businessEntity == null)
{
return(null);
}
GenreEntity dataEntity = new GenreEntity()
{
ID = businessEntity.ID,
Name = businessEntity.Name,
PrivateMarks = businessEntity.PrivateMarks,
Description = businessEntity.Description,
Comments = businessEntity.Comments
};
return(dataEntity);
}
private ICollection <genreMovie> GenreMovieMapperInitializer(GenreEntity genreEntity)
{
Mapper.Initialize(t =>
{
t.CreateMap <GenreEntity, ICollection <genreMovie> >()
.ConstructProjectionUsing(
p => p.GenreMovies.Select(
gm => new genreMovie
{
genre_Style = p.genreStyle,
movie_id = gm.movie_id,
description = p.GenreMovies.FirstOrDefault(g => g.movie_id == gm.movie_id).description
}
).ToList()
);
});
return(Mapper.Map <GenreEntity, ICollection <genreMovie> >(genreEntity));
}
public void SeedGenres(MoviesContext context)
{
if (context.Genres.Any())
{
return;
}
var actionGenreEntity = new GenreEntity
{
Name = "Action"
};
var dramaGenreEntity = new GenreEntity
{
Name = "Drama"
};
context.Genres.Add(actionGenreEntity);
context.SaveChanges();
_roles.Add(actionGenreEntity.Id, actionGenreEntity);
_roles.Add(dramaGenreEntity.Id, dramaGenreEntity);
}
public bool AddGenreDAL(GenreEntity newGenre)
{
try
{
bool isAdded = false;
var ObjContext = new CinestarEntitiesDAL();
var objGenre = new Genre();
objGenre.GenreId = newGenre.GenreId;
objGenre.GenreName = newGenre.GenreName;
ObjContext.Genres.Add(objGenre);
int NoOfrowsAffected = ObjContext.SaveChanges();
if (NoOfrowsAffected > 0)
{
isAdded = true;
}
return(isAdded);
}
catch (Exception Ex)
{
return(false);
}
}
public GenreEntity Update(int id, GenreEntity item)
{
_context.GenreItems.Update(item);
return(item);
}
public void Add(GenreEntity item)
{
_context.GenreItems.Add(item);
}
public void Delete(GenreEntity genre)
{
_context.Genre.Remove(genre);
}
public bool UpdateGenre(string genre_style, GenreEntity movieEntity)
{
throw new NotImplementedException();
}
private genre GenreMapperInitializer(GenreEntity genreEntity)
{
Mapper.Initialize(x => x.CreateMap <GenreEntity, genre>()
.ForMember(dest => dest.genreMovies, opt => opt.Ignore()));
return(Mapper.Map <GenreEntity, genre>(genreEntity));
}
