Example #1
0
        public ActionResult Create([Bind(Include = "ID,dataInicioConcretizacao,dataFimConcretizacao,local,AtividadeFK")] Concretizacao concretizacao, string[] opcoesEscolhidasDeFunc)
        {
            if (opcoesEscolhidasDeFunc == null)
            {
                ModelState.AddModelError("", "Necessita escolher pelo menos um Funcionário para associar à concretização.");
                // gerar a lista de objetos de PA que podem ser associados a Criança
                ViewBag.ListaObjetosDeFunc = db.Funcionarios.OrderBy(f => f.Nome).ToList();

                // devolver controlo à View
                return(View(concretizacao));
            }

            List <Funcionarios> listaDeObjetosDeFuncEscolhidos = new List <Funcionarios>();

            foreach (string item in opcoesEscolhidasDeFunc)
            {
                Funcionarios f = db.Funcionarios.Find(Convert.ToInt32(item));
                // adicioná-lo à lista
                listaDeObjetosDeFuncEscolhidos.Add(f);
            }

            // adicionar a lista ao objeto de crianças
            concretizacao.ListaDeObjetosDeFuncionario = listaDeObjetosDeFuncEscolhidos;

            if (ModelState.IsValid)
            {
                db.Concretizacao.Add(concretizacao);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.AtividadeFK        = new SelectList(db.Atividades, "ID", "Nome", concretizacao.AtividadeFK);
            ViewBag.ListaObjetosDeFunc = db.Funcionarios.OrderBy(f => f.Nome).ToList();
            return(View(concretizacao));
        }
Example #2
0
        public ActionResult Create([Bind(Include = "ID,Turno,dataInicioPA,dataFimPA")] PlanoDeAtividades planoDeAtividades, string [] opcoesEscolhidasDeConc)
        {
            if (opcoesEscolhidasDeConc == null)
            {
                ModelState.AddModelError("", "Necessita escolher pelo menos uma Concretização para associar ao plano de atividades.");

                ViewBag.ListaObjetosDeConc = db.Concretizacao.OrderBy(f => f.dataInicioConcretizacao).ToList();

                // devolver controlo à View
                return(View(planoDeAtividades));
            }

            List <Concretizacao> listaDeObjetosDeConcEscolhidos = new List <Concretizacao>();

            foreach (string item in opcoesEscolhidasDeConc)
            {
                Concretizacao c = db.Concretizacao.Find(Convert.ToInt32(item));
                // adicioná-lo à lista
                listaDeObjetosDeConcEscolhidos.Add(c);
            }

            // adicionar a lista ao objeto de crianças
            planoDeAtividades.ListaDeObjetosDeConcretizacao = listaDeObjetosDeConcEscolhidos;

            if (ModelState.IsValid)
            {
                db.PlanoDeAtividades.Add(planoDeAtividades);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(planoDeAtividades));
        }
Example #3
0
        public ActionResult DeleteConfirmed(int id)
        {
            Concretizacao concretizacao = db.Concretizacao.Find(id);

            db.Concretizacao.Remove(concretizacao);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Example #4
0
        // GET: Concretizacaos/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(RedirectToAction("Index"));
            }
            Concretizacao concretizacao = db.Concretizacao.Find(id);

            if (concretizacao == null)
            {
                return(RedirectToAction("Index"));
            }
            return(View(concretizacao));
        }
Example #5
0
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(RedirectToAction("Index"));
            }
            Concretizacao concretizacao = db.Concretizacao.Find(id);

            if (concretizacao == null)
            {
                return(RedirectToAction("Index"));
            }
            ViewBag.AtividadeFK        = new SelectList(db.Atividades, "ID", "Nome", concretizacao.AtividadeFK);
            ViewBag.ListaObjetosDeFunc = db.Funcionarios.OrderBy(f => f.Nome).ToList();
            return(View(concretizacao));
        }
Example #6
0
        public ActionResult Edit([Bind(Include = "ID,dataInicioConcretizacao,dataFimConcretizacao,local,AtividadeFK")] Concretizacao concretizacao, string[] opcoesEscolhidasDeFunc)
        {
            var conc = db.Concretizacao.Include(f => f.ListaDeObjetosDeFuncionario).Where(f => f.ID == concretizacao.ID).SingleOrDefault();



            if (ModelState.IsValid)
            {
                conc.dataInicioConcretizacao = concretizacao.dataInicioConcretizacao;
                conc.dataFimConcretizacao    = concretizacao.dataFimConcretizacao;
                conc.local       = concretizacao.local;
                conc.AtividadeFK = concretizacao.AtividadeFK;
            }
            else
            {
                ViewBag.AtividadeFK        = new SelectList(db.Atividades, "ID", "Nome", concretizacao.AtividadeFK);
                ViewBag.ListaObjetosDeFunc = db.Funcionarios.OrderBy(f => f.Nome).ToList();
                return(View(concretizacao));
            }
            // tentar fazer o UPDATE
            if (TryUpdateModel(conc, "", new string[] { nameof(conc.dataInicioConcretizacao), nameof(conc.dataFimConcretizacao), nameof(conc.local), nameof(conc.AtividadeFK), nameof(conc.ListaDeObjetosDeFuncionario) }))
            {
                var elementosDeFunc = db.Funcionarios.ToList();

                if (opcoesEscolhidasDeFunc != null)
                {
                    // se existirem opções escolhidas, vamos associá-las
                    foreach (var ff in elementosDeFunc)
                    {
                        if (opcoesEscolhidasDeFunc.Contains(ff.ID.ToString()))
                        {
                            // se uma opção escolhida ainda não está associada, cria-se a associação
                            if (!conc.ListaDeObjetosDeFuncionario.Contains(ff))
                            {
                                conc.ListaDeObjetosDeFuncionario.Add(ff);
                            }
                        }
                        else
                        {
                            // caso exista associação para uma opção que não foi escolhida,
                            // remove-se essa associação
                            conc.ListaDeObjetosDeFuncionario.Remove(ff);
                        }
                    }
                }
                else
                {
                    // não existem opções escolhidas!
                    // vamos eliminar todas as associações
                    foreach (var ff in elementosDeFunc)
                    {
                        if (conc.ListaDeObjetosDeFuncionario.Contains(ff))
                        {
                            conc.ListaDeObjetosDeFuncionario.Remove(ff);
                        }
                    }
                }
            }

            // guardar as alterações
            db.SaveChanges();

            // devolver controlo à View
            return(RedirectToAction("Index"));
        }