public async Task <IActionResult> Edit(int id, [Bind("RequisitoId,MateriaRequisito")] Requisito requisito)
        {
            if (id != requisito.RequisitoId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(requisito);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!RequisitoExists(requisito.RequisitoId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(requisito));
        }
Beispiel #2
0
        public void DeletarUmResultadoEsperado()
        {
            /**
             * Cenário 4: Serão criados 3 resultados esperados.
             * O resultado 2 deverá ser deletado e os outros dois devem ser reordenados para 1 e 2 respectivamente.
             */

            Projeto        projeto1       = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo         modulo1        = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito      requisito1     = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste      casoteste1     = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePasso casoTestePasso = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado1 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado2 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(2, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado3 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");

            casoTestePassoResultadoEsperado2.Delete();

            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 2");
        }
Beispiel #3
0
        public void CriarSequenciaResultadoEsperado()
        {
            /**
             * Cenário 1: Serão criados 3 resultados esperados para um passo.
             * O sistema deverá cria-los com a sequencia 1, 2, 3 respectivamente.
             */

            Projeto        projeto1       = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo         modulo1        = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito      requisito1     = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste      casoteste1     = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePasso casoTestePasso = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado1 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado2 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(2, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado3 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");
        }
        public IActionResult Novo(Requisito requisito)
        {
            if (ModelState.IsValid)
            {
                Banco.Requisitos.Add(requisito);
                Banco.SaveChanges();

                foreach (int id in requisito.Desenvolvedores)
                {
                    Banco.Atribuicoes.Add(new Atribuicao {
                        DesenvolvedorId = id,
                        RequisitoId     = requisito.Id,
                        Desenvolvedor   = Banco.Desenvolvedores.Find(id),
                        Requisito       = Banco.Requisitos.Find(requisito.Id)
                    });
                }
                Banco.SaveChanges();
            }
            else
            {
                ViewBag.Desenvolvedores = Banco.Desenvolvedores.OrderBy(d => d.Nome);
                return(View("Form", requisito));
            }


            return(RedirectToAction("index"));
        }
Beispiel #5
0
        protected void grvMatrizRequisito_RowDataBound(object sender, GridViewRowEventArgs e)
        {
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                //Coloca o código do registro na primeira coluna do grid e
                //adiciona label invisível com o seu ID para colocar posteriormente
                //nos checkboxes
                Requisito bean       = (Requisito)e.Row.DataItem;
                Label     labelTexto = (Label)e.Row.FindControl("lblTexto");
                labelTexto.Text = bean.CodigoRequisito;
                Label labelId = (Label)e.Row.FindControl("lblId");
                labelId.Text = bean.Id.ToString();

                GridViewRow row = e.Row;

                //verifica requisitos rastreados pela primeira coluna e marca o checkbox
                //das colunas seguintes onde houver rastreabilidade marcada
                foreach (Requisito rastreado in bean.RequisitosRastreados)
                {
                    CheckBox check = (CheckBox)e.Row.FindControl(rastreado.Id.ToString());
                    check.Checked = true;
                }
                //Concatena o ID do requisito não-funcional jah renderizado no template com o id dos funcionais
                //para gerar o relacionamento posteriormente quando marcado ou desmarcado
                foreach (Control checkBox in row.Controls)
                {
                    AdicionaIdEmCheckBox(checkBox, labelId.Text);
                }
            }
        }
        /// <summary>
        /// metodo criar que instancia um objeto da factore
        /// </summary>
        /// <param name="session">seção</param>
        /// <param name="requisitos">objeto de requisito</param>
        /// <param name="txPassos">passos</param>
        /// <param name="txSumario">sumario</param>
        /// <param name="txPrecondicoes">precondição</param>
        /// <param name="save">save</param>
        /// <returns>caso de teste</returns>
        public static CasoTeste Criar(Session session, Requisito requisitos, String txPassos = "", String txSumario = "",
                                      String txPrecondicoes = "", bool save = false)
        {
            //String TxResultadoEsperado = "",
            CasoTeste casoteste = new CasoTeste(session);

            //if (String.IsNullOrEmpty(TxPassos))
            //    casoteste.TxPassos = GetDescricao();

            if (String.IsNullOrEmpty(txSumario))
            {
                casoteste.TxSumario = GetDescricao();
            }

            //if (String.IsNullOrEmpty(TxResultadoEsperado))
            //    casoteste.TxResultadoEsperado = GetDescricao();

            //if (String.IsNullOrEmpty(TxPrecondicoes))
            //    casoteste.TxPrecondicoes = GetDescricao();

            casoteste.Requisito = requisitos;

            if (save)
            {
                casoteste.Save();
            }

            return(casoteste);
        }
Beispiel #7
0
        public async Task <IActionResult> Criar(Requisito requisito)
        {
            UsuarioADE user = await ObterUsuarioLogado();

            if (ModelState.IsValid)
            {
                try
                {
                    await _requisitoServices.CadastrarAsync(user, requisito);

                    return(Json("<p class='text-sucess'>Requisito criado com sucesso!</p>"));
                }
                catch (Exception ex)
                {
                    await LogError(ex.Message, ex.Source, Dominio.Models.Enums.EnumTipoLog.CriacaoRequisito);

                    return(Json($"<p class='text-danger'>Ocorreu um erro ao criar o requisito</p><p>{ex.Message}</p>"));
                }
            }
            else
            {
                string Erros = "<ul>";
                IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
                foreach (ModelError modelState in allErrors)
                {
                    Erros += $"<li>{modelState.ErrorMessage}</li>";
                }
                Erros += "</ul>";
                return(Json(Erros));
            }
        }
        public void SalvarRequisitoJaExitenteEmUmProjeto()
        {
            Projeto projeto1 = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo  modulo1  = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            /**
             * Cenário 2: Serão criados 3 requisitos para o projeto e em seguida será deletado o segundo requisito.
             * Após isso, será criado mais 1 modulo, que o wex deverá criar como RF_4.
             */

            Requisito requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);

            Assert.AreEqual("RF_01.01", requisito1.TxID, "O ID do modulo deveria ser RF_01.01");

            requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);

            Assert.AreEqual("RF_01.02", requisito1.TxID, "O ID do modulo deveria ser RF_01.02");

            Assert.AreEqual("RF_01.03", RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true).TxID, "O ID do modulo deveria ser RF_01.03");

            //Criar o delete Rf_1.2

            requisito1.Delete();

            Assert.AreEqual("RF_01.04", RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true).TxID, "O ID do modulo deveria ser RF_01.04");
        }
        public void CriarSequenciaPreCondicao()
        {
            /**
             * Cenário 1: Serão criadas 3 informações adicionais para uma pré-condição.
             * O sistema deverá salvá-lo com a sequência correta
             */

            Projeto              projeto1              = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo               modulo1               = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito            requisito1            = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste            casoteste1            = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional1 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(1, casoTestePreCondicaoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional2 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(2, casoTestePreCondicaoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional3 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(3, casoTestePreCondicaoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");
        }
        public async Task <IActionResult> ListadoResultFinalizado(Requisito requisito)
        {
            var listaRequisitos = new List <Requisito>();

            try
            {
                var lista = await ListarRequisitosFinalizado();

                if (requisito?.Documento?.RequisitoLegal?.IdOrganismoControl != -1)
                {
                    lista = lista.Where(c => c.Documento.RequisitoLegal.IdOrganismoControl == requisito.Documento.RequisitoLegal.IdOrganismoControl).ToList();
                }

                if (requisito.IdActorResponsableGestSeg != -1)
                {
                    lista = lista.Where(c => c.IdActorResponsableGestSeg == requisito.IdActorResponsableGestSeg).ToList();
                }

                if (requisito.IdProyecto != -1)
                {
                    lista = lista.Where(c => c.IdProyecto == requisito.IdProyecto).ToList();
                }

                if (requisito.Anno != null)
                {
                    lista = lista.Where(c => c.FechaCumplimiento?.Year == requisito.Anno).ToList();
                }

                return(PartialView("_ListadoFinalizado", lista));
            }
            catch (Exception)
            {
                return(StatusCode(500));
            }
        }
Beispiel #11
0
        public async Task <IdentityResult> CadastrarAdministradorAsync(UsuarioADE usuarioCriado, string password, bool existente, EnumTipoUsuario Funcao)
        {
            usuarioCriado.DataHoraInclusao           = DateTime.Now;
            usuarioCriado.TipoRecebimentoNotificacao = EnumTipoRecebimentoNotificacao.Geral;
            IdentityResult result;

            if (existente)
            {
                result = await CadastrarAdministradorExistente(usuarioCriado, password, Funcao);
                await AtualizarAsync(usuarioCriado, null);
            }
            else
            {
                result = await _userManager.CreateAsync(usuarioCriado, password);

                if (result.Succeeded)
                {
                    ServicoRequisito servicoRequisito = new ServicoRequisito(ref unitOfWork);
                    Requisito        requisito        = await servicoRequisito.BuscarUm(x => x.NomeRequisito == "Email");

                    RequisitoDeUsuario rdu = new RequisitoDeUsuario(usuarioCriado.Id, requisito.Identificador, usuarioCriado.Email, usuarioCriado);
                    _servicoRequisitoDeUsuario = _servicoRequisitoDeUsuario ?? new ServicoRequisitoUsuario(ref unitOfWork);
                    await _servicoRequisitoDeUsuario.CadastrarAsync(rdu);

                    await _userManager.AddToRoleAsync(usuarioCriado, Funcao.GetDescription());
                }
            }
            return(result);
        }
        public void AdicionarInformação()
        {
            /**
             * Cenário 5: Serão criadas 3 informações adicionais para uma pré-condição.
             * O sistema deverá informar quantas informações estão cadastradas no sistema.
             */

            Projeto              projeto1              = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo               modulo1               = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito            requisito1            = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste            casoteste1            = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional1 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(1, casoTestePreCondicaoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional2 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(2, casoTestePreCondicaoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional3 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(3, casoTestePreCondicaoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional4 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(4, casoTestePreCondicaoInfoAdicional4.NbSequencia, "A sequência deveria ser 3");

            casoTestePreCondicaoInfoAdicional3.Delete();

            Assert.AreEqual(3, casotestePreCondicao1._NbInformacoesAdicionais, "O valor deveria ser 3");
        }
        protected void btnSalvar_Click(object sender, EventArgs e)
        {
            if (this.IsValid)
            {
                try
                {
                    requisito = service.CriarNovoRequisito(txtNome.Text.Trim(), txtDescricao.Text.Trim(),
                                                           int.Parse(ddlTipo.SelectedValue), usuarioCorrente, projetoCorrente);

                    Response.Redirect(Request.CurrentExecutionFilePath + "?value=" + requisito.Id + "&mensagem=Requisito cadastrado com sucesso! ");
                }
                catch (NegocioException ne)
                {
                    erro = ne.Message;
                    log.Error(erro, ne);
                    ExibirMensagem(erro, lblMensagem, "60", ConfigurationManager.AppSettings["TOPO_MENSAGEM"], ConfigurationManager.AppSettings["COR_FUNDO_MENSAGEM"], ConfigurationManager.AppSettings["COR_TEXTO_MENSAGEM"]);
                }
                catch (Exception ex)
                {
                    erro = "Erro desconhecido. ";
                    log.Error(erro, ex);
                    ExibirMensagem(erro, lblMensagem, "60", ConfigurationManager.AppSettings["TOPO_MENSAGEM"], ConfigurationManager.AppSettings["COR_FUNDO_MENSAGEM"], ConfigurationManager.AppSettings["COR_TEXTO_MENSAGEM"]);
                }
            }
        }
Beispiel #14
0
        /// <summary>
        /// método crair
        /// </summary>
        /// <param name="session">session</param>
        /// <param name="modulo">modulo</param>
        /// <param name="txNome">TxNome</param>
        /// <param name="txDescricao">TxDescricao</param>
        /// <param name="txLinkPrototipo">TxLinkPrototipo</param>
        /// <param name="save">bool</param>
        /// <returns>requisito</returns>
        public static Requisito Criar(Session session, Modulo modulo, string txNome = "", String txDescricao = "", String txLinkPrototipo = "", bool save = false)
        {
            Requisito requisito = new Requisito(session);

            if (String.IsNullOrEmpty(txNome))
            {
                requisito.TxNome = GetDescricao();
            }

            if (String.IsNullOrEmpty(txDescricao))
            {
                requisito.TxDescricao = GetDescricao();
            }

            if (String.IsNullOrEmpty(txLinkPrototipo))
            {
                requisito.TxLinkPrototipo = GetDescricao();
            }

            requisito.Modulo = modulo;

            if (save)
            {
                requisito.Save();
            }

            return(requisito);
        }
        public void DeletarUmaPreCondicao()
        {
            /**
             * Cenário 4: Serão criadas 3 informações adicionais para uma pré-condição.
             * A informação adicional 2 deverá ser deletada e as outras duas devem ser reordenadas para 1 e 2 respectivamente.
             */

            Projeto              projeto1              = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo               modulo1               = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito            requisito1            = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste            casoteste1            = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional1 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(1, casoTestePreCondicaoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional2 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(2, casoTestePreCondicaoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional3 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(3, casoTestePreCondicaoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            casoTestePreCondicaoInfoAdicional2.Delete();

            Assert.AreEqual(1, casoTestePreCondicaoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePreCondicaoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");
        }
        //<summary> Método que se encarga de un nuevo Requisito</summary>
        //<author> Gabriela Gutiérrez Corrales </author>
        //<param name = "pNombre"> variable de tipo String que almacena el nombre del requisito  </param>
        //<param name= "pdescripcion" > variable de tipo String que almacena la descripción del requisito  </param>
        //<returns>No retorna valor</returns>
        public void crearRequisito(String pnombre, String pdescripcion)
        {
            try
            {
                Requisito objRequisito = ContenedorMantenimiento.Instance.crearRequisito(pnombre, pdescripcion);
                if (objRequisito.IsValid)
                {
                    RequisitoRepository.Instance.Insert(objRequisito);
                    //UoW.RequisitoRepository.Insert(objRequisito);
                }
                else
                {
                    StringBuilder sb = new StringBuilder();
                    foreach (RuleViolation rv in objRequisito.GetRuleViolations())
                    {
                        sb.Append(rv.ErrorMessage);
                    }
                    throw new ApplicationException(sb.ToString());
                }
            }

            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #17
0
        public async Task <IActionResult> Editar(Requisito Requisito, string Mensagem)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    try
                    {
                        UsuarioADE usuario = await ObterUsuarioLogado();

                        await _requisitoServices.AtualizarAsync(usuario, Requisito, Mensagem);

                        ViewBag.Retorno = "Requisito alterado com sucesso!";
                        await unitOfWork.Commit();
                    }
                    catch (DbUpdateConcurrencyException)
                    {
                        if (_requisitoServices.ListarAsync().Result.Any(req => req.Identificador == Requisito.Identificador))
                        {
                            ModelState.AddModelError("Falha", "Esse requisito já está sendo alterado");
                        }
                    }
                }
                return(await Editar(Requisito.Identificador));
            }
            catch (Exception ex)
            {
                await LogError(ex.Message, ex.Source + "-" + ex.TargetSite.Name, Dominio.Models.Enums.EnumTipoLog.AlteracaoRequisito);

                ModelState.AddModelError("Falha", "Ocorreu um erro ao alterar o requisito, contate o suporte para maior exclarecimento");
                return(await Editar(Requisito.Identificador));
            }
        }
Beispiel #18
0
        public ActionResult Create(RequisitoView model)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var requisito = new Requisito {
                        Descricao = model.Descricao, DtInclusao = DateTime.Now
                    };
                    requisito.TipoRequisito = Context.TipoRequisito.FirstOrDefault(tr => tr.TipoRequisitoId == model.TipoRequisitoId);
                    requisito.Projeto       = Context.Projeto.FirstOrDefault(p => p.ProjetoId == model.ProjetoId);
                    Context.Requisito.Add(requisito);

                    Context.SaveChanges();
                    return(RedirectToAction("Details", "Projeto", new { Id = model.ProjetoId }));
                }
                var tiposRequisitos = Context.TipoRequisito.AsEnumerable();
                return(View());
            }
            catch
            {
                var tiposRequisitos = Context.TipoRequisito.AsEnumerable();
                return(View());
            }
        }
 public CriarViewModel(string selection, CriarDocumentoViewModel criarDocumentoViewModel, Curso curso, Requisito requisito)
 {
     CriarDocumentoViewModel = criarDocumentoViewModel;
     Curso     = curso;
     Requisito = requisito;
     Selection = selection;
 }
        public void ReordenarSequencia()
        {
            /**
             * Cenário 2: Serão criadoas 3 informações adicionais para um resultado esperado.
             * Em seguida  as sequências serão mudadas.
             * O sistema deverá reordenar corretamente
             */

            //Passo 1
            Projeto        projeto1        = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo         modulo1         = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito      requisito1      = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste      casoteste1      = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePasso casotestePasso1 = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);
            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado1 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casotestePasso1, "", true);

            CasoTestePassoResultadoEsperadoInformacaoAdicional casoTestePassoResultadoEsperadoInfoAdicional1 = CasoTestePassoResultadoEsperadoInformacaoAdicionalFactory.Criar(SessionTest,
                                                                                                                                                                               casoTestePassoResultadoEsperado1, true);

            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");

            //Passo 2
            CasoTestePassoResultadoEsperadoInformacaoAdicional casoTestePassoResultadoEsperadoInfoAdicional2 = CasoTestePassoResultadoEsperadoInformacaoAdicionalFactory.Criar(SessionTest,
                                                                                                                                                                               casoTestePassoResultadoEsperado1, true);
            CasoTestePassoResultadoEsperadoInformacaoAdicional casoTestePassoResultadoEsperadoInfoAdicional3 = CasoTestePassoResultadoEsperadoInformacaoAdicionalFactory.Criar(SessionTest,
                                                                                                                                                                               casoTestePassoResultadoEsperado1, true);

            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            //Passo 3

            casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia = 2;
            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            //Passo 4

            casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia = 3;
            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 3");

            //Passo 5

            casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia = 2;
            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            //Passo 6

            casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia = 1;
            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 3");
        }
        public ActionResult Requisito(string idRequisito, string nombre, string descripcion, string prioridad, string fuente,
                                      string estabilidad, string estado, string tipoRequisito, string medida, string escala,
                                      string fecha, string incremento, string tipo)
        {
            Requisito requisito = new Requisito(idRequisito, nombre, descripcion, prioridad, fuente, estabilidad, estado,
                                                tipoRequisito, medida, escala, fecha, incremento, tipo);

            return(View());
        }
Beispiel #22
0
        public void DescerSequenciaResultadoEsperado()
        {
            /**
             * Cenário 2: Serão criados 3 resultados esperados para um passo.
             * Em seguida  as sequências do resultado esperado serão mudadas.
             * O sistema deverá reordenar as sequências dos resultados restantes corretamente.
             */

            //Passo 1

            Projeto        projeto1       = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo         modulo1        = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito      requisito1     = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste      casoteste1     = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePasso casoTestePasso = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado1 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");

            //Passo 2

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado2 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);
            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado3 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(2, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");

            //Passo 3

            casoTestePassoResultadoEsperado1.NbSequencia = 2;
            Assert.AreEqual(1, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");

            //Passo 4

            casoTestePassoResultadoEsperado2.NbSequencia = 3;
            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 3");

            //Passo 5

            casoTestePassoResultadoEsperado2.NbSequencia = 2;
            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");

            //Passo 6

            casoTestePassoResultadoEsperado3.NbSequencia = 1;
            Assert.AreEqual(1, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 3");
        }
        //public IEnumerable<Requisito> mostrarRequisitoTB(TipoBeca ptipoBeca)
        //{

        //    return RequisitoRepository.Instance.GetLista(ptipoBeca);
        //}

        //<summary> Método que se encarga de modificcar un requisito</summary>
        //<author> Valeria Ramírez Cordero </author>
        //<param name = "pnombre"> variable de tipo String que almacena el nombre del requisito  </param>
        //<param name = "pdescripcion"> variable de tipo String que almacena la descripción del requisito</param>
        //<param name = "pid"> variable de tipo int que almacena el id del requisito</param>
        //<returns> No retorna valor </returns>
        public void modificarRequisito(String pnombre, String pdescripcion, int pid)
        {
            try{
                Requisito objRequisito = ContenedorMantenimiento.Instance.crearRequisito(pnombre, pdescripcion, pid);
                RequisitoRepository.Instance.Update(objRequisito);
            }
            catch (Exception ex) {
                throw ex;
            }
        }
        private static LinkedList <long> EliminarRecursos(LinkedList <long> recursosDisponibles, long actual)
        {
            Requisito tmp = GetRequisito(actual);

            for (int i = 0; i < tmp.Recursos.Count; i++)
            {
                recursosDisponibles.Remove(tmp.Recursos.ElementAt(i).Id);
            }
            return(recursosDisponibles);
        }
        public void ReordenarSequencia()
        {
            /**
             * Cenário 2: Serão criados 3 pré-condições para um caso de teste.
             * Em seguida  as sequências serão mudadas.
             * O sistema deverá reordenar corretamente
             */

            //Passo 1

            Projeto   projeto1   = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo    modulo1    = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste casoteste1 = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);

            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            Assert.AreEqual(1, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 1");

            //Passo 2

            CasoTestePreCondicao casotestePreCondicao2 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);
            CasoTestePreCondicao casotestePreCondicao3 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            Assert.AreEqual(2, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 3");

            //Passo 3

            casotestePreCondicao1.NbSequencia = 2;
            Assert.AreEqual(1, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 3");

            //Passo 4

            casotestePreCondicao2.NbSequencia = 3;
            Assert.AreEqual(1, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 3");

            //Passo 5

            casotestePreCondicao2.NbSequencia = 2;
            Assert.AreEqual(1, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 3");

            //Passo 6

            casotestePreCondicao3.NbSequencia = 1;
            Assert.AreEqual(1, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 3");
        }
        public async Task <IActionResult> Create([Bind("RequisitoId,MateriaRequisito")] Requisito requisito)
        {
            if (ModelState.IsValid)
            {
                _context.Add(requisito);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(requisito));
        }
        private static long CalcularSatisfaccion(Requisito actual)
        {
            long salida = 0;

            for (int i = 0; i < actual.Valoraciones.Count; i++)
            {
                salida += actual.Valoraciones[i] * App.Clientes[i].Importancia;
            }

            return(salida);
        }
Beispiel #28
0
 public void Update(Requisito requisito)
 {
     try
     {
         _crudRequisito.Update(requisito);
     }
     catch (Exception e)
     {
         ExceptionManager.GetInstance().Process(e);
     }
 }
Beispiel #29
0
        public IActionResult Del(int id)
        {
            Requisito req = ctx.Requisitos.Find(id);

            if (req != null)
            {
                ctx.Requisitos.Remove(req);
                ctx.SaveChanges();
            }

            return(RedirectToAction("Index", "Dashboard"));
        }
Beispiel #30
0
        public BaseEntity BuildObject(Dictionary <string, object> row)
        {
            var requisito = new Requisito
            {
                Id      = GetIntValue(row, DB_COL_PERMISOS_ID),
                Permiso = GetStringValue(row, DB_COL_PERMISO),
                Placa   = GetStringValue(row, DB_COL_PLACA),
                Estado  = GetStringValue(row, DB_COL_ESTADO)
            };

            return(requisito);
        }
        public ActionResult CriarRequisito(Requisito requisitoModelo)
        {
            //Salvar Requisito

            requisitoModelo.projetoId = (int)Session["ProjetoID"];

            using (ReqcyclerEntities db = new ReqcyclerEntities())
            {
                db.Requisito.Add(requisitoModelo);
                db.SaveChanges();

                //Associar Pacote e Requisito
                db.PacoteRequisito.Add(new PacoteRequisito { pacoteId = requisitoModelo.pacoteId, requisitoId = requisitoModelo.id });
                db.SaveChanges();
            }

            int ProjetoId = (int)Session["ProjetoID"];

            return Redirect("~/Requisito/Index?ProjetoId=" + ProjetoId);
        }