public async Task <RoundMember> UpdateScoring(RoundMember roundMember)
        {
            var dbRoundMember = await dbContext
                                .Set <Entities.RoundMember>()
                                .Include(rm => rm.Scoring)
                                .Include(rm => rm.Member)
                                .ThenInclude(bm => bm.Scoring)
                                .Include(rm => rm.Member)
                                .ThenInclude(bm => bm.Bandit)
                                .ThenInclude(b => b.Scoring)
                                .FirstOrDefaultAsync(rm => rm.Round.Id == roundMember.Round.Id &&
                                                     rm.Member.Bandit.Id == roundMember.Member.Bandit.Id);

            if (dbRoundMember == null)
            {
                return(roundMember);
            }

            dbRoundMember.Scoring.Update(roundMember.Scoring);
            dbRoundMember.Member.Scoring.Update(roundMember.Member.Scoring);
            dbRoundMember.Member.Bandit.Scoring.Update(roundMember.Member.Bandit.Scoring);

            await dbContext.SaveChangesAsync();

            return(roundMember);
        }
        public async Task <Round> Get(int id)
        {
            var dbRound = await dbContext
                          .Set <Entities.Round>()
                          .Include(r => r.Sheriff)
                          .ThenInclude(rm => rm.Scoring)
                          .Include(r => r.Sheriff)
                          .ThenInclude(rm => rm.Member)
                          .ThenInclude(bm => bm.Band)
                          .ThenInclude(b => b.Boss)
                          .ThenInclude(b => b.Bandit)
                          .Include(r => r.Sheriff)
                          .ThenInclude(rm => rm.Member)
                          .ThenInclude(bm => bm.Bandit)
                          .Include(r => r.Members)
                          .ThenInclude(rm => rm.Scoring)
                          .Include(r => r.Members)
                          .ThenInclude(rm => rm.Member)
                          .ThenInclude(bm => bm.Bandit)
                          .FirstOrDefaultAsync(r => r.Id == id);

            if (dbRound == null)
            {
                return(null);
            }

            var dbBoss = dbRound.Sheriff.Member.Band.Boss.Bandit;
            var boss   = Bandit.Create(dbBoss.Id, dbBoss.Name, dbBoss.Email);

            var dbBand = dbRound.Sheriff.Member.Band;
            var band   = Band.Create(dbBand.Id, dbBand.Name, boss);

            var dbSheriff = dbRound.Sheriff.Member.Bandit;
            var sheriff   = Bandit.Create(dbSheriff.Id, dbSheriff.Name, dbSheriff.Email);

            var sheriffMember = BandMember.From(sheriff, band);

            band.Members.Add(sheriffMember);

            var round = Round.Create(
                dbRound.Id,
                dbRound.Name,
                dbRound.Place,
                dbRound.DateTime,
                sheriffMember,
                Enumerable.Empty <BandMember>()
                );

            var sheriffScoring = dbRound.Sheriff.Scoring.ToModel();

            round.Sheriff.Scoring.Add(sheriffScoring);

            foreach (var rm in dbRound.Members)
            {
                if (rm.Member.Bandit.Id == round.Sheriff.Member.Bandit.Id)
                {
                    round.Members.Add(round.Sheriff);
                    continue;
                }

                var dbBandit = rm.Member.Bandit;
                var bandit   = Bandit.Create(dbBandit.Id, dbBandit.Name, dbBandit.Email);

                var bandMember  = BandMember.From(bandit, band);
                var roundMember = RoundMember.From(bandMember, round);

                var memberScoring = rm.Scoring.ToModel();
                roundMember.Scoring.Add(memberScoring);

                round.Members.Add(roundMember);
            }

            return(round);
        }