I use DTO class in API layer and I struggle to map DTO class to "model" class in generic Repository.cs in core layer.
Repository.cs :
namespace DTOMap.Core.Repository.Generic
{
public class Repository<T> : IRepository<T> where T : class
{
private DTOMapContext _context;
private DbSet<T> _table;
private IMapper _mapper;
public Repository(DTOMapContext context)
{
_context = context;
_table = _context.Set<T>();
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile<MyMapper>();
});
_mapper = config.CreateMapper();
}
public T Add(T obj)
{
// Here how to use My Mapper to save a book or an author generically
// Sth like :
// temp = _table.Add(_mapper.Map<T>(obj)); Here I want to map Dto to model to save in the db
// return = (_mapper.Map<T>(temp)); Here I want to map Model to DTO to collect it in API
// but I can't have a reference to TDTO
throw new NotImplementedException();
}
}
}
I show you the other classes that I find useful (I only implement Add function for this example and I am a beginner in .Net) :
Author.cs
namespace DTOMap.Core.Models
{
[Table("Author")]
internal class Author
{
[Key]
public int id { get; set; }
[Required, MaxLength(255)]
public string firstName { get; set; }
[Required,MaxLength(255)]
public string lastName { get; set; }
}
}
Book.cs
namespace DTOMap.Core.Models
{
[Table("Book")]
internal class Book
{
[Key]
public int id { get; set; }
[Required,MaxLength(255)]
public string name { get; set; }
[Required]
public int authorId { get; set; }
[Required]
public Author author { get; set; }
}
}
AuthorDTO.cs
namespace DTOMap.Domain.DTO
{
public class AuthorDTO
{
public int id { get; set; }
public string firstName { get; set; }
public string lastName { get; set; }
}
}
BookDTO.cs
namespace DTOMap.Domain.DTO
{
public class BookDTO
{
public int id { get; set; }
public string name { get; set; }
public int authorId { get; set; }
public AuthorDTO author { get; set; }
}
}
IRepository.cs
namespace DTOMap.Domain.Interface
{
public interface IRepository<T>
{
T Add(T obj);
}
}
MyMapper.cs
namespace DTOMap.Core
{
public class MyMapper : Profile
{
public MyMapper()
{
CreateMap<Book, BookDTO>();
CreateMap<BookDTO, Book>();
CreateMap<Author, AuthorDTO>();
CreateMap<AuthorDTO, Author>();
}
}
}
program.cs
... Some Fcts
builder.Services.AddTransient<IRepository<BookDTO>, BookRepository>();
builder.Services.AddTransient<IRepository<AuthorDTO>, AuthorRepository>();
... Some Fcts
If you need any other information, please ask me.
Related
I'm trying to update an entity using entity framework but, everytime I try to do it, it raises an error saying that a nested entity the main class contains cannot be tracked.
These are my classes:
public abstract class BaseEntity
{
public int Id { get; set; }
}
public class Dashboard : BaseEntity
{
public int Order { get; set; }
public string Title { get; set; }
public bool Enabled { get; set; }
public virtual ICollection<Submenu> Submenu { get; set; }
}
public class Submenu : BaseEntity
{
public int Order { get; set; }
public bool Enabled { get; set; }
public string Title { get; set; }
public string Image { get; set; }
public string Descriptions { get; set; }
public virtual ICollection<Action> Actions { get; set; }
public int DashboardId { get; set; }
public virtual Dashboard Dashboard { get; set; }
}
public class Action : BaseEntity
{
public string Type { get; set; }
public string Label { get; set; }
public string Url { get; set; }
public string Extension { get; set; }
public virtual Submenu Submenu { get; set; }
public int SubmenuId { get; set; }
}
The one I am using to update is Dashboard, which contains the rest of the classes.
I'm trying to do it using a generic service layer and a generic repository that are defined this way:
public class GenericService<T> : IGenericService<T> where T : BaseEntity
{
private readonly IBaseRepository<T> baseRepository;
public GenericService(IBaseRepository<T> baseRepository)
{
this.baseRepository = baseRepository;
}
public async Task Update(T entity, T attachedEntity)
{
await baseRepository.Update(entity, attachedEntity);
}
}
public class BaseRepository<T> : IBaseRepository<T> where T : BaseEntity
{
private readonly PortalContext dataContext;
private DbSet<T> DbSet { get; set; }
public BaseRepository(PortalContext context)
{
dataContext = context;
DbSet = dataContext.Set<T>();
}
public async Task Update(T entity, T attachedEntity)
{
dataContext.Entry(attachedEntity).State = EntityState.Detached;
DbSet.Attach(entity);
dataContext.Entry(entity).State = EntityState.Modified;
await dataContext.SaveChangesAsync();
}
}
And, at last but no least, this is the way I am configuring everything at Startup.cs
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<PortalContext>(
options => options.UseSqlServer(Configuration.GetConnectionString("PortalContext"))
);
services.AddTransient(typeof(IGenericService<>), typeof(GenericService<>));
services.AddTransient(typeof(IBaseRepository<>), typeof(BaseRepository<>));
services.AddTransient<Func<string, ClaimsPrincipal, IRoleCheck>>((serviceProvider) =>
{
return (controllerName, claimsPrincipal) =>
new RoleCheck(serviceProvider.GetRequiredService<IGenericService<Dossier>>(),
serviceProvider.GetRequiredService<IGenericService<DossierTemplate>>(),
serviceProvider.GetRequiredService<IGenericService<Dashboard>>(),
controllerName, claimsPrincipal);
});
}
What the application first does is calling the RoleCheck class to retrieve and filter the required entities and, after that, the user can update them.
When I call the update function at the controller
public async Task<ActionResult<Dashboard>> Put(int id, [FromBody] Dashboard dashboard)
{
var currentDashboard = await service.Get(id);
if (currentDashboard == null)
{
return NotFound();
}
await service.Update(dashboard, currentDashboard);
return Ok();
}
I always receive the next error at the repository:
error
Is there something I am doing wrong? I have been stuck with this for a week now...
Thanks in advance and sorry for the long text, but I wanted it to be clear.
I could finally solve it by adding .AsNoTracking() at the Get() method of my repository:
public async Task<T> Get(int id, Func<IQueryable<T>, IIncludableQueryable<T, object>> includes)
{
IQueryable <T> query = DbSet.AsNoTracking();
if (includes != null)
{
query = includes(query);
}
return await query.FirstOrDefaultAsync(m => m.Id == id);
}
I am trying to map my domain entity to DTO. What I am getting in generated query is wrongly concatenated property name.
This is my entity class: (some code is removed for brevity)
public class Product : BaseEntity
{
public int ProductId { get; set; }
public string Name { get; set; }
public virtual EntityUnit EntityUnit { get; set; }
}
This my DTO
public class ProductDto : IMapFrom<Product>
{
public int Id { get; set; }
public string Unit { get; set; }
public void Mapping(Profile profile)
{
profile.CreateMap<Product, ProductDto>()
.ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.EntityUnit.Name));
}
}
This is my EntityUnit class:
public class EntityUnit : BaseEntity
{
public int UnitId { get; set; }
public string Name { get; set; }
}
After all this is the generated query:(on mini-profiler)
Actually that must be p.UnitId instead of EntityUnitUnitId (which works). Automapper version is 9.0
What I am doing wrong here?
When I call the object model variable ,straight from the database, I receive all the needed data about the dependent entity: MenuItem.
When i use an automapper it displays the mapped MenuItem object as null.
Automapping for getAll and getAllById works.
Principle Entity: ItemCategory
DependentEntity: MenuItem
Please help.
Mapping Profile:
public class MappingProfile: Profile
{
public MappingProfile()
{
CreateMap<ItemCategory, ItemCategoryDto>();
CreateMap<ItemType, ItemTypeDto>();
CreateMap<ItemStatus, ItemStatusDto>();
CreateMap<MenuItem, MenuItemDto>();
//CreateMap<ItemCategory, ItemCategoryDto>();
//CreateMap<ItemType, ItemTypeDto>();
//CreateMap<ItemStatus, ItemStatusDto>();
}
}
ItemCategory Model class:
public partial class ItemCategory
{
public ItemCategory()
{
MenuItem = new HashSet<MenuItem>();
}
public Guid Id { get; set; }
public string Description { get; set; }
public virtual ICollection<MenuItem> MenuItem { get; set; }
}
MenuItem Model Class:
public partial class MenuItem
{
public MenuItem()
{
Menu = new HashSet<Menu>();
MenuItemAllergy = new HashSet<MenuItemAllergy>();
MenuItemIngredient = new HashSet<MenuItemIngredient>();
MenuItemPrice = new HashSet<MenuItemPrice>();
MenuItemSpecial = new HashSet<MenuItemSpecial>();
OrderMenuItem = new HashSet<OrderMenuItem>();
}
public Guid Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
public Guid ItemCategoryId { get; set; }
public Guid ItemTypeId { get; set; }
public Guid ItemStatusId { get; set; }
public virtual ItemCategory ItemCategory { get; set; }
public virtual ItemStatus ItemStatus { get; set; }
public virtual ItemType ItemType { get; set; }
public virtual ICollection<Menu> Menu { get; set; }
public virtual ICollection<MenuItemAllergy> MenuItemAllergy { get; set; }
public virtual ICollection<MenuItemIngredient> MenuItemIngredient { get; set; }
public virtual ICollection<MenuItemPrice> MenuItemPrice { get; set; }
public virtual ICollection<MenuItemSpecial> MenuItemSpecial { get; set; }
public virtual ICollection<OrderMenuItem> OrderMenuItem { get; set; }
}
ItemCategoryDTO:
public class ItemCategoryDto
{
public Guid Id { get; set; }
public string Description { get; set; }
public IEnumerable<MenuItemDto> MenuItems { get; set; }
}
MenuItemDTO:
public class MenuItemDto
{
public Guid Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
}
ItemCategory Interface:
public interface IItemCategory: IRepositoryBase<ItemCategory>
{
IEnumerable<ItemCategory> GetAllItemCategories();
ItemCategory GetItemCategoryById(Guid categoryId);
ItemCategory GetItemCategoryWithDetails(Guid categoryId);
}
ItemCategory Repository:
public class ItemCategoryRepository: RepositoryBase<ItemCategory>, IItemCategory
{
public ItemCategoryRepository(eWaiterTestContext repositoryContext)
: base(repositoryContext)
{
}
public IEnumerable<ItemCategory> GetAllItemCategories()
{
return FindAll()
.OrderBy(ic => ic.Description)
.ToList();
}
//Can Add Find By description same way
public ItemCategory GetItemCategoryById(Guid categoryId)
{
return FindByCondition(x => x.Id.Equals(categoryId))
.FirstOrDefault();
}
public ItemCategory GetItemCategoryWithDetails(Guid categoryId)
{
return FindByCondition(x => x.Id.Equals(categoryId))
.Include(z=>z.MenuItem)
.FirstOrDefault();
}
}
ItemCategory Controller to return ItemCategory with related menuItems:
[HttpGet("{id}/menuItem")]
public IActionResult GetItemCategoryWithDetails(Guid id)
{
try
{
var category = _repository.ItemCategory.GetItemCategoryWithDetails(id);
if (category == null)
{
_logger.LogError($"Category with id: {id}, hasn't been found in db.");
return NotFound();
}
else
{
_logger.LogInfo($"Returned owner with details for id: {id}");
var result = _mapper.Map<ItemCategoryDto>(category);
return Ok(result);
}
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetItemCategoryWithDetails action:
straight from the database{ex.Message}");
return StatusCode(500, "Internal server error");
}
}
Names of the properties must be the same, but you just skipped 's' for ItemCategory model
ItemCategory Model class:
public partial class ItemCategory {
public virtual ICollection<MenuItem> MenuItem { get; set; }
}
ItemCategoryDto Model class:
public partial class ItemCategoryDto {
public virtual ICollection<MenuItem> MenuItems { get; set; }
}
Or you can just setup AutoMapper like this :)
public class CategoryMapper: Profile
{
public CategoryMapper()
{
CreateMap<ItemCategory, ItemCategoryDto>()
.ForMember(x => x.MenuItems, x => x.MapFrom(src => src.MenuItem));
}
}
and inject it in Startup.cs
var mappingConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new GemlemMapper());
});
IMapper mapper = mappingConfig.CreateMapper();
services.AddSingleton(mapper);
Hope it will help, also be aware that's all properties which you need to use should be Included by the Include().
I am trying to apply the odata query to my automapper - mappings at my efcore context. Everything works as expected until I use the $select query option.
When I try to use the select keyword in the request to my odata - controller, I get the exception:
SerializationException: 'SourceSourceInjectedQuery`2' cannot be serialized using the ODataMediaTypeFormatter.
I am using the UseAsDataSource - Extension method because it was recommended here on github.
This is my oDataController:
public class StudentsController : ODataController {
private readonly SchoolContext schoolContext;
public StudentsController(SchoolContext schoolContext) {
this.schoolContext = schoolContext;
}
[EnableQuery]
public IActionResult Get() {
return Ok(
schoolContext
.Students
.UseAsDataSource()
.For<StudentVM>()
);
}
}
This is my Entity for EFCore:
public class Student {
public int ID { get; set; }
public string LastName { get; set; }
public string FirstMidName { get; set; }
public DateTime EnrollmentDate { get; set; }
public ICollection<Enrollment> Enrollments { get; set; }
}
And this is my mappingprofile for automapper:
public class StudentVM {
public int ID { get; set; }
public string LastName { get; set; }
public string FirstMidName { get; set; }
}
public class StudentProfile : Profile {
public StudentProfile() {
CreateMap<Student, StudentVM>();
}
}
Do I need some specific mapping to do this?
I figured out I had a mistake in my configuration of the odataservice inside my startup.cs
private static IEdmModel GetEdmModel() {
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Student>("Students");
builder.EntitySet<Course>("Courses");
return builder.GetEdmModel();
}
I put my Entities instead of my ViewModels there. This is the fixed code:
private static IEdmModel GetEdmModel() {
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<StudentVM>("Students");
builder.EntitySet<CourseVM>("Courses");
return builder.GetEdmModel();
}
Now it's working as expected
I have an EntityBase class for FluentNHibernate:
public abstract class EntityBase<T>
{
public EntityBase()
{
}
public static T GetById(int id)
{
return (T)Hibernate.Session.Get<T>(id);
}
public virtual void Save()
{
using (var transaction = Hibernate.Session.BeginTransaction())
{
Hibernate.Session.SaveOrUpdate(this);
transaction.Commit();
}
}
public static IList<T> List()
{
return Hibernate.Session.CreateCriteria(typeof(T)).List<T>();
}
public static IList<T> ListTop(int i)
{
return Hibernate.Session.CreateCriteria(typeof(T)).SetMaxResults(i).List<T>();
}
public virtual void Delete()
{
using (var transaction = Hibernate.Session.BeginTransaction())
{
Hibernate.Session.Delete(this);
transaction.Commit();
}
}
}
I have a base member class also a table in database:
abstract public class BaseMember:EntityBase<BaseMember>
{
public virtual int Id { get; set; }
public virtual string Email { get; set; }
public virtual string Password { get; set; }
public virtual string RecordDate { get; protected set; }
public BaseMember()
{
}
}
I have another Member class that is deriving from BaseMember class:
public class IndividualMember : BaseMember
{
public virtual int Id { get; set; }
public virtual string FirstName { get; set; }
public virtual string LastName { get; set; }
public virtual string PhoneNumber { get; set; }
public virtual string MobilePhoneNumber { get; set; }
public virtual DateTime BirthDate { get; set; }
public virtual bool Gender { get; set; }
public virtual string ProfileImage { get; set; }
public virtual string AddressDefinition { get; set; }
public virtual string ZipCode { get; set; }
public virtual DateTime RecordDate { get; set; }
public IndividualMember()
{
}
}
How can I map those classes with BaseMember and IndividualMember tables in db?
There are different types of Inheritance mapping strategies in Fluent NHibernate.
You can use SubclassMap mapping for derived class.
Strategies : Table-per-class-hierarchy, Table-per-subclass and Table Per Concrete Class.
For table-per-class-hierarchy strategy, you just need to specify the discriminator column.
For more reference :
http://www.codeproject.com/Articles/232034/Inheritance-mapping-strategies-in-Fluent-Nhibernat
https://github.com/jagregory/fluent-nhibernate/wiki/Fluent-mapping#wiki-subclasses