private void MapearModalidades(AlunosFormViewModel obj, Alunos aluno)
        {
            if (!obj.PostModalidades.Any())
            {
                return;
            }

            var excluir   = aluno.Modalidades.Where(m => !obj.PostModalidades.Any(p => p == m.ModalidadeID)).ToList();
            var adicionar = obj.PostModalidades.Where(p => !aluno.Modalidades.Any(a => a.ModalidadeID == p));

            if (excluir.Any())
            {
                foreach (var modalidade in excluir)
                {
                    aluno.removeModalidade(modalidade.Modalidade);
                }
            }

            if (!adicionar.Any())
            {
                return;
            }

            foreach (var id in adicionar)
            {
                var modalidade = _context.Modalidades.Find(id);

                if (modalidade == null)
                {
                    continue;
                }

                aluno.AddModalidade(modalidade);
            }
        }
        public async Task Insert(AlunosFormViewModel obj)
        {
            Alunos aluno = _mapper.Map <Alunos>(obj);

            MapearModalidades(obj, aluno);

            _context.Add(aluno);
            await _context.SaveChangesAsync();
        }
        public async Task <IActionResult> Editar(AlunosFormViewModel aluno)
        {
            try
            {
                await _AlunoService.UpdateAsync(aluno);

                return(RedirectToAction(nameof(Index)));
            }
            catch (ApplicationException e)
            {
                return(RedirectToAction(nameof(Error), new { message = e.Message }));
            }
        }
        public async Task <IActionResult> Editar(int?id)
        {
            if (id == null)
            {
                return(RedirectToAction(nameof(Error), new { message = "Id não informado" }));
            }
            var obj = await _AlunoService.FindByIdAsync(id.Value);

            if (obj == null)
            {
                return(RedirectToAction(nameof(Error), new { message = "Id não localizado" }));
            }
            List <Modalidades> modalidades = await _ModalidadesService.FindAllAsync();

            AlunosFormViewModel viewModel = _mapper.Map <AlunosFormViewModel>(obj);

            ViewBag.Modalidades = new SelectList(modalidades, "ID", "Name");
            return(View(viewModel));
        }
        public async Task UpdateAsync(AlunosFormViewModel obj)
        {
            Alunos aluno = await _context.Alunos.Include(a => a.Modalidades).ThenInclude(a => a.Modalidade).FirstOrDefaultAsync(a => a.ID == obj.ID);

            if (aluno == null)
            {
                throw new NotFoundException("Id Não encontrado");
            }

            try
            {
                aluno = _mapper.Map(obj, aluno);
                MapearModalidades(obj, aluno);
                _context.Update(aluno);
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException e)
            {
                throw new DbConcurrencyException(e.Message);
            }
        }
        public IActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var obj = _alunoService.FindById(id.Value);

            if (obj == null)
            {
                return(NotFound());
            }


            AlunosFormViewModel viewModel = new AlunosFormViewModel {
                Aluno = obj
            };

            return(View(viewModel));
        }
        public async Task <IActionResult> Criar(AlunosFormViewModel aluno)
        {
            await _AlunoService.Insert(aluno);

            return(RedirectToAction(nameof(Index)));
        }