public void Create(Curso curso, int[] professores)
        {
            using (var db = new AppDBContext())
            {
                curso.Professores = db.Professores.Where(p => professores.Contains(p.Id)).ToList();

                db.Cursos.Add(curso);

                db.SaveChanges();
            }
        }
        public ActionResult Delete(int id, Curso curso)
        {
            try
            {
                client.Delete(curso.Id);

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }
        public void Edit(Curso curso, int[] professores)
        {
            using (var db = new AppDBContext())
            {
                var cursoDb = db.Cursos.Include(c => c.Professores).Single(c => c.Id == curso.Id);

                cursoDb.DataLimiteInscricao = curso.DataLimiteInscricao;
                cursoDb.Descricao = curso.Descricao;
                cursoDb.Nome = curso.Nome;

                AtualizarProfessoresCurso(cursoDb, professores, db);

                db.SaveChanges();
            }
        }
        public ActionResult Create(Curso curso)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    CursoServiceRemoto.CursoServiceClient clienteCurso = new CursoServiceRemoto.CursoServiceClient();
                    ProfessorServiceRemote.ProfessorServiceClient clienteProfessor = new ProfessorServiceRemote.ProfessorServiceClient();
                    List<Professor> professores = new List<Professor>();
                    curso.Professores = new List<Professor>();

                    Professor professor;
                    for (int i = 0; i < curso.ProfessoresId.Length; i++)
                    {
                        professor = Mapper.Map<AcmeCursos.Presentation.ProfessorServiceRemote.ProfessorDTO, Professor>(clienteProfessor.Find(curso.ProfessoresId[i]));

                        professores.Add(professor);
                    }

                    CursoDTO cursoDTO = Mapper.Map<Curso, CursoDTO>(curso);

                    cursoDTO.Professores = Mapper.Map<List<ProfessorDTO>>(professores);

                    bool retorno = clienteCurso.Add(cursoDTO);

                    TempData["Mensagem"] = "Curso cadastrado com sucesso";
                    TempData["Sucesso"] = retorno;

                    return RedirectToAction("Index");

                }
                catch (Exception e)
                {
                    ViewBag.Mensagem = e.Message;

                    List<int> professoresId = new List<int>();
                    curso.ProfessoresId.ToList().ForEach(p => professoresId.Add(p));
                    ViewBag.ProfessorSelectList = CriaMultiSelectListProfessores(professoresId);
                    return View("Create", curso);
                }

            }

            return View("Create", curso);
        }
        public ActionResult Delete(Curso curso)
        {
            CursoServiceRemoto.CursoServiceClient cursoWS = new CursoServiceRemoto.CursoServiceClient();
            curso = Mapper.Map<CursoDTO, Curso>(cursoWS.Find(curso.Id));
            CursoServiceRemoto.CursoServiceClient cliente = new CursoServiceRemoto.CursoServiceClient();

            bool retorno = cliente.Delete(Mapper.Map<Curso, CursoDTO>(curso));

            TempData["Mensagem"] = retorno ? "Curso excluído com sucesso" : "Curso não pode ser excluído";

            return RedirectToAction("Index");
        }
        public ActionResult Edit(Curso curso)
        {
            if (ModelState.IsValid)
            {
                CursoServiceRemoto.CursoServiceClient cliente = new CursoServiceRemoto.CursoServiceClient();
                ProfessorServiceRemote.ProfessorServiceClient clienteProfessor = new ProfessorServiceRemote.ProfessorServiceClient();

                List<Professor> professores = new List<Professor>();
                curso.Professores = new List<Professor>();

                Professor professor;
                for (int i = 0; i < curso.ProfessoresId.Length; i++)
                {
                    professor = Mapper.Map<AcmeCursos.Presentation.ProfessorServiceRemote.ProfessorDTO, Professor>(clienteProfessor.Find(curso.ProfessoresId[i]));

                    professores.Add(professor);
                }

                CursoDTO cursoDTO = Mapper.Map<Curso, CursoDTO>(curso);

                cursoDTO.Professores = Mapper.Map<List<ProfessorDTO>>(professores);

                bool retorno = cliente.Update(cursoDTO);

                TempData["Sucesso"] = true;
                TempData["Mensagem"] = retorno ? "Curso atualizado com sucesso" : "Curso não pode ser atualizado";

                return RedirectToAction("Index");
            }

            return View("Edit", curso);
        }
        private void AtualizarProfessoresCurso(Curso curso, int[] professores, AppDBContext db)
        {
            if (professores == null)
            {
                curso.Professores = new List<Professor>();
                return;
            }

            //Lista dos professores que estão selecionados
            var professoresAdicionar = db.Professores.Where(p => professores.Contains(p.Id))
                                                     .ToList();
            //Remove todos os professores que já estão associados ao curso
            professoresAdicionar.RemoveAll(p => curso.Professores.Any(cp => cp.Id == p.Id));
            professoresAdicionar.ForEach(p => curso.Professores.Add(p));

            //Lista de professores que estão associados ao curso mas não estão selecionados
            var professoresRemover = curso.Professores.Where(p => !professores.Contains(p.Id)).ToList();
            professoresRemover.ForEach(p => curso.Professores.Remove(p));
        }