diff --git a/NG_2023_Kanban.BusinessLayer/MappingProfile.cs b/NG_2023_Kanban.BusinessLayer/MappingProfile.cs
index f6dc358..5f0a7cc 100644
--- a/NG_2023_Kanban.BusinessLayer/MappingProfile.cs
+++ b/NG_2023_Kanban.BusinessLayer/MappingProfile.cs
@@ -2,28 +2,102 @@
 using NG_2023_Kanban.BusinessLayer.Models;
 using NG_2023_Kanban.DataLayer.Entities;
 
-namespace NG_2023_Kanban.BusinessLayer
+namespace NG_2023_Kanban
 {
     public class MappingProfile : Profile
     {
         public MappingProfile()
         {
             CreateMap<BoardModel, Board>()
+                .ForMember(boardModel => boardModel.Id,
+                opt => opt.MapFrom(board => board.Id))
+                .ForMember(boardModel => boardModel.Name,
+                opt => opt.MapFrom(board => board.Name))
+                .ForMember(boardModel => boardModel.Users,
+                opt => opt.MapFrom(board => board.Users))
+                .ForMember(boardModel => boardModel.Columns,
+                opt => opt.MapFrom(board => board.Columns))
                 .ReverseMap();
     
             CreateMap<CardModel, Card>()
+                .ForMember(cardModel => cardModel.Id,
+                opt => opt.MapFrom(card => card.Id))
+                .ForMember(cardModel => cardModel.Name,
+                opt => opt.MapFrom(card => card.Name))
+                .ForMember(cardModel => cardModel.Description,
+                opt => opt.MapFrom(card => card.Description))
+                .ForMember(cardModel => cardModel.AssignedId,
+                opt => opt.MapFrom(card => card.AssignedId))
+                .ForMember(cardModel => cardModel.ColumnId,
+                opt => opt.MapFrom(card => card.ColumnId))
+                .ForMember(cardModel => cardModel.SenderId,
+                opt => opt.MapFrom(card => card.SenderId))
+                .ForMember(cardModel => cardModel.Assigned,
+                opt => opt.MapFrom(card => card.Assigned))
+                .ForMember(cardModel => cardModel.Column,
+                opt => opt.MapFrom(card => card.Column))
+                .ForMember(cardModel => cardModel.Sender,
+                opt => opt.MapFrom(card => card.Sender))
+                .ForMember(cardModel => cardModel.Comments,
+                opt => opt.MapFrom(card => card.Comments))
                 .ReverseMap();
             
             CreateMap<ColumnModel, Column>()
+                .ForMember(columnModel => columnModel.Id,
+                opt => opt.MapFrom(column => column.Id))
+                .ForMember(columnModel => columnModel.Name,
+                opt => opt.MapFrom(column => column.Name))
+                .ForMember(columnModel => columnModel.BoardId,
+                opt => opt.MapFrom(column => column.BoardId))
+                .ForMember(columnModel => columnModel.Board,
+                opt => opt.MapFrom(column => column.Board))
+                .ForMember(columnModel => columnModel.Cards,
+                opt => opt.MapFrom(column => column.Cards))
                 .ReverseMap();
 
             CreateMap<CommentModel, Comment>()
+                .ForMember(commentModel => commentModel.Id,
+                opt => opt.MapFrom(comment => comment.Id))
+                .ForMember(commentModel => commentModel.Text,
+                opt => opt.MapFrom(comment => comment.Text))
+                .ForMember(commentModel => commentModel.SenderId,
+                opt => opt.MapFrom(comment => comment.SenderId))
+                .ForMember(commentModel => commentModel.CardId,
+                opt => opt.MapFrom(comment => comment.CardId))
+                .ForMember(commentModel => commentModel.Sender,
+                opt => opt.MapFrom(comment => comment.Sender))
+                .ForMember(commentModel => commentModel.Card,
+                opt => opt.MapFrom(comment => comment.Card))
                 .ReverseMap();
 
             CreateMap<RoleModel, Role>()
+                .ForMember(roleModel => roleModel.Id,
+                opt => opt.MapFrom(role => role.Id))
+                .ForMember(roleModel => roleModel.Name,
+                opt => opt.MapFrom(role => role.Name))
+                .ForMember(roleModel => roleModel.Members,
+                opt => opt.MapFrom(role => role.Members))
                 .ReverseMap();
 
             CreateMap<UserModel, User>()
+                .ForMember(userModel => userModel.Id,
+                opt => opt.MapFrom(user => user.Id))
+                .ForMember(userModel => userModel.FullName,
+                opt => opt.MapFrom(user => user.FullName))
+                .ForMember(userModel => userModel.Username,
+                opt => opt.MapFrom(user => user.Username))
+                .ForMember(userModel => userModel.Password,
+                opt => opt.MapFrom(user => user.Password))
+                .ForMember(userModel => userModel.Boards,
+                opt => opt.MapFrom(user => user.Boards))
+                .ForMember(userModel => userModel.CardsAssigned,
+                opt => opt.MapFrom(user => user.CardsAssigned))
+                .ForMember(userModel => userModel.CardsSent,
+                opt => opt.MapFrom(user => user.CardsSent))
+                .ForMember(userModel => userModel.Comments,
+                opt => opt.MapFrom(user => user.Comments))
+                .ForMember(userModel => userModel.Roles,
+                opt => opt.MapFrom(user => user.Roles))
                 .ReverseMap();
         }
     }
diff --git a/NG_2023_Kanban/MappingProfile.cs b/NG_2023_Kanban/MappingProfile.cs
index a60e283..131ca04 100644
--- a/NG_2023_Kanban/MappingProfile.cs
+++ b/NG_2023_Kanban/MappingProfile.cs
@@ -9,21 +9,95 @@ namespace NG_2023_Kanban
         public MappingProfile()
         {
             CreateMap<BoardDto, BoardModel>()
+                .ForMember(boardDto => boardDto.Id,
+                opt => opt.MapFrom(boardModel => boardModel.Id))
+                .ForMember(boardDto => boardDto.Name,
+                opt => opt.MapFrom(boardModel => boardModel.Name))
+                .ForMember(boardDto => boardDto.Users,
+                opt => opt.MapFrom(boardModel => boardModel.Users))
+                .ForMember(boardDto => boardDto.Columns,
+                opt => opt.MapFrom(boardModel => boardModel.Columns))
                 .ReverseMap();
     
             CreateMap<CardDto, CardModel>()
+                .ForMember(cardDto => cardDto.Id,
+                opt => opt.MapFrom(cardModel => cardModel.Id))
+                .ForMember(cardDto => cardDto.Name,
+                opt => opt.MapFrom(cardModel => cardModel.Name))
+                .ForMember(cardDto => cardDto.Description,
+                opt => opt.MapFrom(cardModel => cardModel.Description))
+                .ForMember(cardDto => cardDto.AssignedId,
+                opt => opt.MapFrom(cardModel => cardModel.AssignedId))
+                .ForMember(cardDto => cardDto.ColumnId,
+                opt => opt.MapFrom(cardModel => cardModel.ColumnId))
+                .ForMember(cardDto => cardDto.SenderId,
+                opt => opt.MapFrom(cardModel => cardModel.SenderId))
+                .ForMember(cardDto => cardDto.Assigned,
+                opt => opt.MapFrom(cardModel => cardModel.Assigned))
+                .ForMember(cardDto => cardDto.Column,
+                opt => opt.MapFrom(cardModel => cardModel.Column))
+                .ForMember(cardDto => cardDto.Sender,
+                opt => opt.MapFrom(cardModel => cardModel.Sender))
+                .ForMember(cardDto => cardDto.Comments,
+                opt => opt.MapFrom(cardModel => cardModel.Comments))
                 .ReverseMap();
             
             CreateMap<ColumnDto, ColumnModel>()
+                .ForMember(columnDto => columnDto.Id,
+                opt => opt.MapFrom(columnModel => columnModel.Id))
+                .ForMember(columnDto => columnDto.Name,
+                opt => opt.MapFrom(columnModel => columnModel.Name))
+                .ForMember(columnDto => columnDto.BoardId,
+                opt => opt.MapFrom(columnModel => columnModel.BoardId))
+                .ForMember(columnDto => columnDto.Board,
+                opt => opt.MapFrom(columnModel => columnModel.Board))
+                .ForMember(columnDto => columnDto.Cards,
+                opt => opt.MapFrom(columnModel => columnModel.Cards))
                 .ReverseMap();
 
             CreateMap<CommentDto, CommentModel>()
+                .ForMember(commentDto => commentDto.Id,
+                opt => opt.MapFrom(commentModel => commentModel.Id))
+                .ForMember(commentDto => commentDto.Text,
+                opt => opt.MapFrom(commentModel => commentModel.Text))
+                .ForMember(commentDto => commentDto.SenderId,
+                opt => opt.MapFrom(commentModel => commentModel.SenderId))
+                .ForMember(commentDto => commentDto.CardId,
+                opt => opt.MapFrom(commentModel => commentModel.CardId))
+                .ForMember(commentDto => commentDto.Sender,
+                opt => opt.MapFrom(commentModel => commentModel.Sender))
+                .ForMember(commentDto => commentDto.Card,
+                opt => opt.MapFrom(commentModel => commentModel.Card))
                 .ReverseMap();
 
             CreateMap<RoleDto, RoleModel>()
+                .ForMember(roleDto => roleDto.Id,
+                opt => opt.MapFrom(roleModel => roleModel.Id))
+                .ForMember(roleDto => roleDto.Name,
+                opt => opt.MapFrom(roleModel => roleModel.Name))
+                .ForMember(roleDto => roleDto.Members,
+                opt => opt.MapFrom(roleModel => roleModel.Members))
                 .ReverseMap();
 
             CreateMap<UserDto, UserModel>()
+                .ForMember(userDto => userDto.Id,
+                opt => opt.MapFrom(userModel => userModel.Id))
+                .ForMember(userDto => userDto.FullName,
+                opt => opt.MapFrom(userModel => userModel.FullName))
+                .ForMember(userDto => userDto.Username,
+                opt => opt.MapFrom(userModel => userModel.Username))
+                .ForMember(userDto => userDto.Password,
+                opt => opt.MapFrom(userModel => userModel.Password))
+                .ForMember(userDto => userDto.Boards,
+                opt => opt.MapFrom(userModel => userModel.Boards))
+                .ForMember(userDto => userDto.CardsAssigned,
+                opt => opt.MapFrom(userModel => userModel.CardsAssigned))
+                .ForMember(userDto => userDto.CardsSent,
+                opt => opt.MapFrom(userModel => userModel.CardsSent))
+                .ForMember(userDto => userDto.Comments,
+                opt => opt.MapFrom(userModel => userModel.Comments))
+                .ForMember(userDto => userDto.Roles,
+                opt => opt.MapFrom(userModel => userModel.Roles))
                 .ReverseMap();
         }
     }