Блог

Мне трудно построить свою древовидную иерархию для dto. Иерархия дерева фиксируется в таблице замыкания с глубинами. Таблица закрытия построена с использованием триггеров в базе данных и не сопоставлена с таблицей команд в EF.

Это моя основная структура классов:

 public class Team
{
  public Guid Id {get; set;}
  public string Title {get; set;}
  public Guid? ParentTeamId {get; set;}
  public Team ParentTeam {get; set;}
}

public class TeamDto
{
  public Guid Id {get; set;}
  public string Title {get; set;}
  public Guid? ParentTeamId {get; set;}
  public ICollection<TeamDto> SubTeams {get; set;} = new List<TeamDto>();
}
 

Таблица закрытия структурирована следующим образом:

 public class Closure
{
  public Guid ParentId {get; set;}
  public Guid ChildId {get; set;}
  public int Depth {get; set;}
}
 

Определения EF являются таковыми:

 public void Configure(EntityTypeBuilder<Team> builder)
    {
        builder.HasOne(p => p.ParentTeam)
            .WithMany()
            .HasForeignKey(k => k.ParentTeamId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Cascade);
    }
public void Configure(EntityTypeBuilder<Closure> builder)
    {
        builder.HasKey(aa => new {aa.ChildId, aa.ParentId});
    }
 

Лучшее, что я смог сделать при запросе против этого, — это заполнить подгруппы на первом уровне. Я использую AutoMapper, но не привязан к автоматическому решению.

Мой запрос на получение списка команд, связанных с пользователем(уже записан в списке команд, и _mapper-это инъекция автоматического сопоставления, а _context-это инъекция контекста моей базы данных) выглядит следующим образом:

 var teamList = await _context.Closures
                .Where(x => teamMemberships.Contains(x.ChildId))
                .Select(x => x.ParentId)
                .ToListAsync();

var query = _context.Teams
  .Where(d => teamList.Contains(d.Id) amp;amp; x.ParentTeamId == null)
  .Select(x => new TeamDto
  {
    Id = x.Id,
    ParentTeamId = x.ParentTeamId,
    Title = x.Title,
    SubTeams = _mapper.Map<List<TeamDto>>(_context.Teams.Where(y => y.ParentTeamId == x.Id))
   })
   .AsQueryable();
 

Мне нужно как-то рекурсивно вытаскивать подгруппы, чтобы в Dto было установлено полное дерево. Я думаю, что может быть запрос, ссылающийся на таблицу закрытия, который мог бы это сделать. dto при отправке в виде json должен выглядеть примерно так:

 [
  {
    "id": "e5500e84-21fb-4b5e-aa9b-a95e51d3dd05",
    "parentId": null,
    "title": "Team 1",
    "subTeams": [
      {
        "id": "05a8d423-feb1-4ea6-9596-d26b18feaa9e",
        "parentId": "e5500e84-21fb-4b5e-aa9b-a95e51d3dd05",
        "title": "Team 1.1",
        "subTeams": [
          {
            "id": "251358d9-3c5a-43b5-91f1-c2e82778c50b",
            "parentId": "05a8d423-feb1-4ea6-9596-d26b18feaa9e",
            "title": "Team 1.1.1",
            "subTeams": []
          },
          {
            "id": "4e27be0b-3a7b-4c8c-8039-2a18e1afcbd0",
            "parentId": "05a8d423-feb1-4ea6-9596-d26b18feaa9e",
            "title": "Team 1.1.2",
            "subTeams": []
          }
        ]
      },
      {
        "id": "2a4d56fc-00f0-4418-80a2-7d870c0ddee5",
        "parentId": "e5500e84-21fb-4b5e-aa9b-a95e51d3dd05",
        "title": "Team 1.2",
        "subTeams": []
      }
    ]
  },
  ...
]
 

Любое понимание очень ценится.

Спасибо Герту Арнольду и другим, кто ответил.

Мое решение действительно включало рекурсивную функцию. Я вытащил все связанные команды, используя таблицу закрытия команд, а затем построил дерево в памяти на основе этого извлечения.

 // teamMemberships is a list of teamIds that are relevant to the user
// I pull all related teams to that list (because a user, for example is a member
// of Team 1 implicitly if they are a member of 1.1, but not explicitly) because
// I need all ancestors and descendants of the selected teams
            var allRelatedTeams = await _context.TeamClosures
                .Where(x => teamMemberships.Contains(x.ChildId) || teamMemberships.Contains(x.ParentId))
                .Select(x => x.ParentId)
                .ToListAsync();

            var teams = _context.Teams
                .Where(x => allRelatedTeams.Contains(x.Id))
                .ProjectTo<TeamDto>(_mapper.ConfigurationProvider)
                .AsQueryable();
            
            var query = teams
                .Where(x => x.ParentTeamId == null)
                .AsQueryable();

            foreach (var team in query)
            {
                ParseSubTeams(team, await teams.ToListAsync());
            }
 

Рекурсивная функция:

         private void ParseSubTeams(TeamDto team, List<TeamDto> teamList)
        {
            var childTeams = teamList
                .Where(x => _context.TeamClosures
                    .Where(y => y.ParentId == team.Id)
                    .Select(z => z.ChildId)
                    .ToList().Contains(x.Id))
                .ToList();
            foreach (var subTeam in childTeams)
            {
                if (subTeam.ParentTeamId == team.Id)
                {
                    team.SubTeams.Add(_mapper.Map<TeamDto>(subTeam));
                    ParseSubTeams(subTeam, teamList);
                }
            }
        }