public ActionResult Editar(int idEncadeamento)
        {
            Encadeamento enc = db.Encadeamento.Where(x => x.Id == idEncadeamento).FirstOrDefault();

            EncadeamentoVO encVo = new EncadeamentoVO();


            if (enc != null)
            {
                encVo.IdEncadeamento = enc.Id;
                encVo.Descricao      = enc.Descricao;

                List <Encadeamento_TestData> enctds = db.Encadeamento_TestData.Where(x => x.IdEncadeamento == enc.Id).OrderByDescending(x => x.Ordem).ToList();

                encVo.qtdTds = enctds.Count();

                List <EncadeamentoVO.TestDataEncadeamento> testDatas = new List <EncadeamentoVO.TestDataEncadeamento>();

                foreach (Encadeamento_TestData enctd in enctds)
                {
                    TestData td  = db.TestData.Where(x => x.Id == enctd.IdTestData).FirstOrDefault();
                    DataPool dp  = db.DataPool.Where(x => x.Id == td.IdDataPool).FirstOrDefault();
                    AUT      aut = db.AUT.Where(x => x.Id == dp.IdAut).FirstOrDefault();

                    List <ParametroScript> ListParametroScript = db.ParametroScript.Where(x => x.IdScript_CondicaoScript == td.IdScript_CondicaoScript).ToList();

                    List <EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento> parametros = new List <EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento>();

                    foreach (ParametroScript ps in ListParametroScript)
                    {
                        Parametro      par = db.Parametro.Where(x => x.Id == ps.IdParametro).FirstOrDefault();
                        TipoParametro  tp  = db.TipoParametro.Where(x => x.Id == ps.IdTipoParametro).FirstOrDefault();
                        ParametroValor pv  = db.ParametroValor.Where(x => x.IdParametroScript == ps.Id).Where(x => x.IdTestData == td.Id).FirstOrDefault();
                        EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento p = new EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento
                        {
                            Descricao               = enc.Descricao,
                            DescricaoParametro      = par.Descricao,
                            DescricaoTestData       = td.Descricao,
                            DescricaoTipoParametro  = tp.Descricao,
                            IdParametroScript       = ps.Id,
                            IdParametroValor        = pv.Id,
                            IdParametroValor_Origem = pv.IdParametroValor_Origem,
                            IdTestData              = td.Id,
                            IdTipoParametro         = tp.Id,
                            Obrigatorio             = ps.Obrigatorio,
                            IdParametro             = par.Id,
                            Tipo  = tp.Descricao,
                            Valor = pv.Valor
                        };
                        parametros.Add(p);
                    }

                    EncadeamentoVO.TestDataEncadeamento testData = new EncadeamentoVO.TestDataEncadeamento
                    {
                        Descricao          = td.Descricao,
                        Id                 = enctd.Id,
                        IdTestData         = td.Id,
                        Ordem              = enctd.Ordem,
                        DescricaoAut       = aut.Descricao,
                        parametros         = parametros,
                        IdAmbienteExecucao = enctd.IdAmbienteExecucao,
                    };
                    testDatas.Add(testData);
                }
                encVo.testDatas = testDatas;
            }
            Usuario user = GetLoggedUser();

            ViewBag.listaTDMs = (from t in db.TDM
                                 join tdm in db.TDM_Usuario on t.Id equals tdm.IdTDM
                                 where tdm.IdUsuario == user.Id
                                 select new TDMVO
            {
                IdTestData = t.Id,
                Descricao = t.Descricao
            }
                                 ).ToList();
            return(View(encVo));
        }
        public JsonResult Salvar(string encadeamentoJson)
        {
            EncadeamentoVO encadeamentoVO = JsonConvert.DeserializeObject <EncadeamentoVO>(encadeamentoJson);

            using (var context = new DbEntities())
            {
                using (var dbContextTransaction = context.Database.BeginTransaction())
                {
                    try
                    {
                        //edição de um encadeamento
                        #region
                        if (encadeamentoVO.IdEncadeamento != null)
                        {
                            log.Info("Entrou na edição do encadeamento " + encadeamentoVO.IdEncadeamento + ".");

                            Encadeamento enc = context.Encadeamento.Where(x => x.Id == encadeamentoVO.IdEncadeamento).FirstOrDefault();
                            enc.Descricao = encadeamentoVO.Descricao;
                            context.Encadeamento.Attach(enc);

                            context.Entry(enc).State = System.Data.Entity.EntityState.Modified;

                            context.SaveChanges();
                            log.Info("Alterando a descrição do encadeamento.");

                            List <EncadeamentoVO.TestDataEncadeamento> listaTdsBanco = (from entd in context.Encadeamento_TestData
                                                                                        where entd.IdEncadeamento == enc.Id
                                                                                        select new EncadeamentoVO.TestDataEncadeamento
                            {
                                Descricao = enc.Descricao,
                                Id = entd.Id,
                                Ordem = entd.Ordem,
                                IdTestData = entd.IdTestData,
                                IdAmbienteExecucao = entd.IdAmbienteExecucao,
                            }
                                                                                        ).ToList();

                            List <EncadeamentoVO.TestDataEncadeamento> listaObjTela = encadeamentoVO.testDatas;


                            for (int i = 0; i < listaObjTela.Count(); i++)
                            {
                                int idTemp         = listaObjTela[i].Id;
                                int enca           = enc.Id;
                                int idTestDataTemp = listaObjTela[i].IdTestData;
                                EncadeamentoVO.TestDataEncadeamento encTemp = listaTdsBanco.Where(x => x.Id == idTemp).FirstOrDefault();

                                if (encTemp == null)
                                {
                                    listaTdsBanco.Add(listaObjTela[i]);
                                    TestData tdAdd = context.TestData.Where(x => x.Id == idTestDataTemp).FirstOrDefault();
                                    Encadeamento_TestData encTdTemp = new Encadeamento_TestData
                                    {
                                        IdTestData         = tdAdd.Id,
                                        IdEncadeamento     = enca,
                                        Ordem              = listaObjTela[i].Ordem,
                                        IdAmbienteExecucao = listaObjTela[i].IdAmbienteExecucao
                                    };
                                    context.Encadeamento_TestData.Add(encTdTemp);
                                    context.SaveChanges();
                                    log.Info("Associando o testData" + tdAdd.Id + " ao Encadeamento.");
                                }
                            }

                            for (int z = 0; z < listaTdsBanco.Count(); z++)
                            {
                                int idTemp = listaTdsBanco[z].Id;
                                EncadeamentoVO.TestDataEncadeamento encTemp = listaObjTela.Where(x => x.Id == idTemp).FirstOrDefault();

                                if (encTemp == null)
                                {
                                    listaTdsBanco.Remove(listaTdsBanco[z]);
                                    Encadeamento_TestData encDelete = context.Encadeamento_TestData.Where(x => x.Id == idTemp).FirstOrDefault();

                                    context.Encadeamento_TestData.Remove(encDelete);
                                    context.SaveChanges();
                                    log.Info("Desassociando o testData" + encDelete.IdTestData + " do Encadeamento.");
                                }
                            }

                            for (int w = 0; w < listaTdsBanco.Count(); w++)
                            {
                                int idTemp = listaTdsBanco[w].Id;

                                EncadeamentoVO.TestDataEncadeamento encTemp = listaObjTela.Where(x => x.Id == idTemp).FirstOrDefault();

                                if (encTemp != null)
                                {
                                    for (int y = 0; y < encTemp.parametros.Count(); y++)
                                    {
                                        int?           idParametroScript = encTemp.parametros[y].IdParametroScript;
                                        int?           idTestData        = encTemp.parametros[y].IdTestData;
                                        ParametroValor pv = context.ParametroValor.Where(x => x.IdParametroScript == idParametroScript).Where(x => x.IdTestData == idTestData).FirstOrDefault();

                                        if (pv != null)
                                        {
                                            pv.Valor = encTemp.parametros[y].Valor;
                                            pv.IdParametroValor_Origem = encTemp.parametros[y].IdParametroValor_Origem;

                                            context.ParametroValor.Attach(pv);

                                            context.Entry(pv).State = System.Data.Entity.EntityState.Modified;

                                            context.SaveChanges();
                                            log.Info("Atualizando o ParametroValor " + pv.Id + ", do ParametroScript " + idParametroScript + " e do TestData " + idTestData + ".");
                                        }
                                    }
                                }
                            }

                            string json = JsonConvert.SerializeObject(true, Formatting.Indented);

                            dbContextTransaction.Commit();
                            log.Info("Salvando a edição do encadeamento " + encadeamentoVO.IdEncadeamento);
                            return(Json(json, JsonRequestBehavior.AllowGet));
                        }
                        #endregion
                        //novo encadeamento
                        #region
                        else
                        {
                            //adicionando Encadeamento
                            Encadeamento encadeamento = new Encadeamento {
                                Descricao = encadeamentoVO.Descricao
                            };
                            context.Encadeamento.Add(encadeamento);
                            context.SaveChanges();
                            log.Info("Inclusão do encadeamento " + encadeamento.Id);

                            foreach (EncadeamentoVO.TestDataEncadeamento testDataEncadeamento in encadeamentoVO.testDatas)
                            {
                                //criando relacao testdata encadeamento
                                Encadeamento_TestData encadeamentoTestData = new Encadeamento_TestData
                                {
                                    IdEncadeamento     = encadeamento.Id,
                                    IdTestData         = testDataEncadeamento.IdTestData,
                                    Ordem              = testDataEncadeamento.Ordem,
                                    IdAmbienteExecucao = testDataEncadeamento.IdAmbienteExecucao
                                };

                                context.Encadeamento_TestData.Add(encadeamentoTestData);
                                context.SaveChanges();
                                log.Info("Associando o testData " + testDataEncadeamento.IdTestData + " ao Encadeamento " + encadeamento.Id);

                                //populando a tabela de parametro valor
                                foreach (EncadeamentoVO.TestDataEncadeamento.ParametroEncadeamento parametrosEncadeamento in testDataEncadeamento.parametros)
                                {
                                    ParametroValor pv = context.ParametroValor.Where(x => x.Id == parametrosEncadeamento.IdParametroValor).FirstOrDefault();

                                    pv.Valor = parametrosEncadeamento.Valor;

                                    context.ParametroValor.Attach(pv);

                                    context.Entry(pv).State = System.Data.Entity.EntityState.Modified;

                                    context.SaveChanges();
                                    log.Info("Salvando o ParametroValor " + pv.Id + " do TestData " + testDataEncadeamento.IdTestData);
                                }
                            }
                            string json = JsonConvert.SerializeObject(true, Formatting.Indented);

                            dbContextTransaction.Commit();
                            log.Info("Salvando o Encadeamento " + encadeamento.Id);
                            return(Json(json, JsonRequestBehavior.AllowGet));
                        }
                        #endregion
                    }
                    catch (Exception ex)
                    {
                        string json = JsonConvert.SerializeObject(false, Formatting.Indented);
                        dbContextTransaction.Rollback();
                        return(Json(json, JsonRequestBehavior.AllowGet));
                    }
                }
            }
        }