public void processa(int IdScriptCondicaoScript, int IdTestData)
{
DbEntities db = new DbEntities();
//Simula os parâmetros de saída //////////////////////////
List <ParametroScript> ListaParametroScript = db.ParametroScript.Where(x => x.IdScript_CondicaoScript == IdScriptCondicaoScript && x.IdTipoParametro == (int)EnumTipoParametro.Output).ToList();
Dictionary <string, string> parametroSaida = new Dictionary <string, string>();
ListaParametroScript.ForEach(ps =>
{
Random randNum = new Random();
randNum.Next(4);
string value = db.Parametro.Where(x => x.Id == ps.IdParametro).FirstOrDefault().Descricao + "_Teste_" + randNum.Next();
ParametroValor pv = db.ParametroValor.Where(x => x.IdParametroScript == ps.Id && x.IdTestData == IdTestData).FirstOrDefault();
pv.Valor = value;
// anexar objeto ao contexto
db.ParametroValor.Attach(pv);
//Prepara a entidade para uma Edição
db.Entry(pv).State = System.Data.Entity.EntityState.Modified;
// informa que o obejto será modificado
db.SaveChanges();
});
/////////////////////////////////////////////////////////
}
public JsonResult CarregarParametroValor(string idScriptCondicaoScript, string idTestData)
{
DbEntities db = new DbEntities();
int scriptCondicaoScript = Int32.Parse(idScriptCondicaoScript);
int id = Int32.Parse(idTestData);
List <ParametroScript> listParametroScript = db.ParametroScript.Where(x => x.IdScript_CondicaoScript == scriptCondicaoScript && x.VisivelEmTela == true).ToList();
List <ParametroValorVO> listParametroValorVO = new List <ParametroValorVO>();
int IdStatus = db.TestData.Where(x => x.Id == id).FirstOrDefault().IdStatus;
foreach (ParametroScript ps in listParametroScript)
{
Parametro p = db.Parametro.Where(x => x.Id == ps.IdParametro).FirstOrDefault();
//realiza busca dos valores dos parâmetros associados ao testdata, caso não seja encontrado será adicionado a lista como vazio
ParametroValor pv = db.ParametroValor.Where(x => x.IdParametroScript == ps.Id && x.IdTestData == id).FirstOrDefault();
if (pv == null)
{
listParametroValorVO.Add(new ParametroValorVO {
IdStatusTestData = IdStatus, Valor = "", Id = 0, IdParametroScript = ps.Id, Descricao = p.Descricao, Tipo = p.Tipo, IdParametroValor = p.Id, IdTipoParametro = ps.IdTipoParametro, Obrigatorio = ps.Obrigatorio
});
}
else
{
listParametroValorVO.Add(new ParametroValorVO {
IdStatusTestData = IdStatus, Valor = pv.Valor, Id = pv.Id, IdParametroScript = ps.Id, Descricao = p.Descricao, Tipo = p.Tipo, IdParametroValor = p.Id, IdTipoParametro = ps.IdTipoParametro, Obrigatorio = ps.Obrigatorio
});
}
}
string json = JsonConvert.SerializeObject(listParametroValorVO, Formatting.Indented);
return(Json(json, JsonRequestBehavior.AllowGet));
}
public void CarregarParametosEntrada(int IdTestData, int IdScript_CondicaoScript)
{
if (DicionarioParametros.Count() > 0)
{
db = new DbEntities();
this.ListaParametroScript = db.ParametroScript.Where(x => x.IdScript_CondicaoScript == IdScript_CondicaoScript && x.IdTipoParametro == (int)EnumTipoParametro.Input).ToList();
ListaParametroScript.ForEach(x =>
{
Parametro par = db.Parametro.Find(x.IdParametro);
if (this.DicionarioParametros.ContainsKey(par.Descricao))
{
ParametroValor pv = db.ParametroValor.Where(y => y.IdParametroScript == x.Id && y.IdTestData == IdTestData).FirstOrDefault();
pv.Valor = this.DicionarioParametros[par.Descricao];
db.ParametroValor.Attach(pv);
//Prepara a entidade para uma Edição
db.Entry(pv).State = System.Data.Entity.EntityState.Modified;
// informa que o obejto será modificado
db.SaveChanges();
}
});
}
}
/// <summary>
/// Retorna todos os parametros valores referente ao TestData passado por parametro.
/// </summary>
public ParametroValor GetParametrosValores(int IdTestData)
{
ParametroValor item = repositorio.Get(IdTestData);
if (item != null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(item);
}
public ActionResult MultiplicarTestData()
{
int Id = Int32.Parse(Request.Form.Get("TestDataId"));
int QtdMassas = Int32.Parse(Request.Form.Get("QtdMassa"));
TestData TestData = db.TestData.Where(x => x.Id == Id).FirstOrDefault();
try
{
for (int i = 0; i < QtdMassas; i++)
{
TestData TesteDataTemp = new TestData()
{
IdDataPool = TestData.IdDataPool,
IdStatus = (int)EnumStatusTestData.Cadastrada,
IdScript_CondicaoScript = TestData.IdScript_CondicaoScript,
IdUsuario = TestData.IdUsuario,
Descricao = TestData.Descricao,
GerarMigracao = TestData.GerarMigracao,
CasoTesteRelativo = TestData.CasoTesteRelativo,
Observacao = TestData.Observacao,
TempoEstimadoExecucao = TestData.TempoEstimadoExecucao
};
db.TestData.Add(TesteDataTemp);
db.SaveChanges();
List <ParametroValor> parametros = db.ParametroValor.Where(x => x.IdTestData == Id).ToList();
foreach (ParametroValor item in parametros)
{
ParametroValor parametroValor = new ParametroValor()
{
IdTestData = TesteDataTemp.Id,
IdParametroScript = item.IdParametroScript,
ParametroScript = item.ParametroScript,
Valor = item.Valor
};
db.ParametroValor.Add(parametroValor);
db.SaveChanges();
}
}
this.FlashSuccess("Massas de teste adicionadas com sucesso.");
}
catch (Exception ex)
{
this.FlashError(ex.Message);
}
return(RedirectToAction("Editar/" + TestData.IdDataPool, "DataPool"));
}
public void CarregarParametrosSaida(int IdTestData, int IdScript_CondicaoScript)
{
db = new DbEntities();
this.ListaParametroScript = db.ParametroScript.Where(x => x.IdScript_CondicaoScript == IdScript_CondicaoScript && x.IdTipoParametro == (int)EnumTipoParametro.Output).ToList();
ListaParametroScript.ForEach(ps =>
{
ParametroValor pv = db.ParametroValor.Where(x => x.IdParametroScript == ps.Id && x.IdTestData == IdTestData).FirstOrDefault();
string key = db.Parametro.Where(x => x.Id == ps.IdParametro).FirstOrDefault().Descricao;
string valor = pv.Valor;
if (DicionarioParametros.ContainsKey(key))
{
DicionarioParametros[key] = valor;
}
else
{
DicionarioParametros.Add(key, valor);
}
});
}
public static void Play(string id, string idFaseTeste, string idMaquinaVirtual, bool opcaoTelegram, string idAmbienteExecucao, Usuario user, bool PlayTestData = true)
{
#region Conecção DbEntities
DbEntities db = new DbEntities();
#endregion
try
{
#region Debug
Log.Info("Entrada no metodo Play().");
#endregion
string mensagem = "";
var testDatas = new List <int>();
List <ListaTestDatas> listaTestDatas = new List <ListaTestDatas>();
int IdDatapool;
int[] ids = null;
#region Debug
//Verifica se o Play é da entidade DataPool ou da TestData
#endregion
#region Play Por TestData
if (PlayTestData)
{
#region Debug
Log.Info("Foi identificado o tipo de Play por TestData.");
#endregion
Char delimiter = ',';
ids = id.Split(delimiter).Select(n => Convert.ToInt32(n)).ToArray();
int idTemp = ids[0];
TestData TestData = db.TestData.FirstOrDefault(x => x.Id == idTemp);
IdDatapool = db.DataPool.FirstOrDefault(x => x.Id == TestData.IdDataPool).Id;
#region Debug
Log.Info("Iniciando carregamento de informações dos TestData(s).");
#endregion
listaTestDatas =
(from dp in db.DataPool
join td in db.TestData on dp.Id equals td.IdDataPool
where ids.Contains(td.Id)
select new ListaTestDatas
{
IdDatapool = dp.Id,
IdTestData = td.Id,
IdStatus = td.IdStatus
}).ToList();
if (listaTestDatas.Where(x => x.IdStatus != (int)EnumStatusTestData.Cadastrada).ToList().Count() > 0)
{
#region Debug
Log.Info("Não é possível iniciar a execução de massas com o status diferente de CADASTRADA!");
#endregion
throw new Exception("Não é possível iniciar a execução de massas com o status diferente de CADASTRADA!");
}
}
#endregion
#region Play Por DataPool
else
{
IdDatapool = Int32.Parse(id);
listaTestDatas =
(from dp in db.DataPool
join td in db.TestData on dp.Id equals td.IdDataPool
where dp.Id == IdDatapool
select new ListaTestDatas
{
IdDatapool = dp.Id,
IdTestData = td.Id
}).ToList();
}
#endregion
#region Busca TestData Com Parâmetros Obrigatótios
for (int i = 0; i < listaTestDatas.Count; i++)
{
int idTestDataAtual = listaTestDatas[i].IdTestData;
List <ParametrosValores> listaParametrosObrigatorios =
(from pv in db.ParametroValor
join ps in db.ParametroScript on pv.IdParametroScript equals ps.Id
join p in db.Parametro on ps.IdParametro equals p.Id
where pv.IdTestData == idTestDataAtual && ps.Obrigatorio == true
select new ParametrosValores
{
IdTestData = IdDatapool,
IdDatapool = idTestDataAtual,
IdParametro = p.Id,
IdParametroValor = pv.Id,
Descricao = p.Descricao,
Valor = pv.Valor,
Obrigatorio = ps.Obrigatorio
}).ToList();
for (int w = 0; w < listaParametrosObrigatorios.Count; w++)
{
//Verifico se o Script tem o parametro Ambiente sistema, caso tenha, o valor do parametro é atualizado com o valor que vem da tela do play
if (listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Ambiente_Sistema || listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Ambiente)
{
int idAmbExec = Int32.Parse(idAmbienteExecucao);
int?_idParamValor = listaParametrosObrigatorios[w].IdParametroValor;
if (_idParamValor != null)
{
ParametroValor pv = db.ParametroValor.Where(x => x.Id == _idParamValor).FirstOrDefault();
AmbienteExecucao ambExec = db.AmbienteExecucao.Where(x => x.Id == idAmbExec).FirstOrDefault();
if (ambExec.Id == (int)EnumAmbienteExec.Ti1_Siebel8 || ambExec.Id == (int)EnumAmbienteExec.Ti8_Siebel8)
{
string amb = ambExec.Descricao.Substring(ambExec.Descricao.IndexOf("http"), ambExec.Descricao.Length - ambExec.Descricao.IndexOf("http"));
pv.Valor = amb;
listaParametrosObrigatorios[w].Valor = amb;
}
else
{
pv.Valor = ambExec.Descricao;
listaParametrosObrigatorios[w].Valor = ambExec.Descricao;
}
// anexar objeto ao contexto
db.ParametroValor.Attach(pv);
//Prepara a entidade para uma Edição
db.Entry(pv).State = System.Data.Entity.EntityState.Modified;
// informa que o obejto será modificado
db.SaveChanges();
}
}
if (listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Dados_De_Entrada ||
listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Dados_De_Saida ||
listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Fase ||
listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Nome_Do_Caso_De_Teste ||
listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Numero_Do_Caso_De_Teste ||
listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Prj ||
listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Resultado_Esperado ||
listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Titulo)
{
int? _idParamValor = listaParametrosObrigatorios[w].IdParametroValor;
ParametroValor pv = db.ParametroValor.Where(x => x.Id == _idParamValor).FirstOrDefault();
if (!pv.Valor.Equals(""))
{
pv.Valor = "TESTE";
}
// anexar objeto ao contexto
db.ParametroValor.Attach(pv);
//Prepara a entidade para uma Edição
db.Entry(pv).State = System.Data.Entity.EntityState.Modified;
// informa que o obejto será modificado
db.SaveChanges();
listaParametrosObrigatorios[w].Valor = pv.Valor;
}
if (listaParametrosObrigatorios[w].IdParametro == (int)EnumParametro.Evidencia_Autor)
{
int? _idParamValor = listaParametrosObrigatorios[w].IdParametroValor;
ParametroValor pv = db.ParametroValor.Where(x => x.Id == _idParamValor).FirstOrDefault();
pv.Valor = user.Login;
// anexar objeto ao contexto
db.ParametroValor.Attach(pv);
//Prepara a entidade para uma Edição
db.Entry(pv).State = System.Data.Entity.EntityState.Modified;
// informa que o obejto será modificado
db.SaveChanges();
listaParametrosObrigatorios[w].Valor = user.Login;
}
else
{
if (listaParametrosObrigatorios[w].Valor == "" || listaParametrosObrigatorios[w].Valor == null)
{
if (!testDatas.Contains(listaTestDatas[i].IdTestData))
{
testDatas.Add(listaTestDatas[i].IdTestData);
}
}
}
}
}
#region Debug
Log.Info("Ibusca de parametros obrigatorios nao preenchidos concluida.");
#endregion
#endregion
#region Valida Se Possui Parâmetros Obrigatórios Não Preenchidos
#region Debug
Log.Info("Iniciando validacao de parametros obrigatorios nao preenchidos.");
#endregion
if (testDatas.Count > 0)
{
string combindedString = string.Join(",", testDatas.ToArray());
string stringFinal = "";
for (int i = 0; i < combindedString.Length; i++)
{
if (i % 100 == 0)
{
if (i == 0)
{
stringFinal += combindedString[i];
}
else
{
stringFinal += combindedString[i] + "<br >";
}
}
else
{
stringFinal += combindedString[i];
}
}
#region Debug
Log.Info("O(s) TestData(s): abaixo possui(em) parâmetro(s) obrigatório(s) - destacados em vermelho - que não foram preenchidos <br>" + stringFinal);
#endregion
mensagem = "O(s) TestData(s): abaixo possui(em) parâmetro(s) obrigatório(s) - destacados em vermelho - que não foram preenchidos <br>" + stringFinal;
}
else
{
bool EnvioTelegram = opcaoTelegram;
// Utilizando o Datapool da tela, substituir a query do script e salvar os dados na tabela de execução (Controle_Ambiente)
if (PlayTestData)
{
ReplaceQuery(ids.OfType <int>().ToList(), Int32.Parse(idFaseTeste), Int32.Parse(idMaquinaVirtual), Int32.Parse(idAmbienteExecucao), user, EnvioTelegram); // enviar o Datapool da tela
}
else
{
ReplaceQuery(ObtemIdTestData(Int32.Parse(id)), Int32.Parse(idFaseTeste), Int32.Parse(idMaquinaVirtual), Int32.Parse(idAmbienteExecucao), user, EnvioTelegram); // enviar o Datapool da tela
}
string pAginaDoJob = null;
int idAmbv = Int32.Parse(idMaquinaVirtual);
AmbienteVirtual ambv = db.AmbienteVirtual.Where(x => x.Id == idAmbv).FirstOrDefault();
if (ambv.IP != null)
{
mensagem = "Execução iniciada com sucesso para a VDI " + ambv.IP;
#region Debug
Log.Info("Execução iniciada com sucesso para a VDI " + ambv.IP);
#endregion
pAginaDoJob = ConfigurationSettings.AppSettings[ambv.IP];
}
else
{
#region Debug
Log.Info("Não foi possível definir o Job do Jenkins.");
#endregion
mensagem = "Não foi possível definir o Job do Jenkins.";
}
#region Debug
Log.Info("Chamada do metodo runJobJenkinsRemote().");
#endregion
runJobJenkinsRemote(pAginaDoJob);
#region Debug
Log.Info("Metodo de execucao do Jenkins finalizado.");
#endregion
//log.Info("Execução iniciada.");
//Usar esta opção para rodar local
//runJobJenkinsLocal(pAginaDoJob, "brucilin.de.gouveia", "brucilin.de.gouveia");
}
#endregion
}
catch (Exception ex)
{
#region Log Error
Log.Error("Ocorreu o seguinte erro no método Play(). " + ex.Message);
Log.Error(ex.StackTrace);
#endregion
}
}
private void SalvaParametros(int idTestData, int scriptCondicaoScript, bool edicao)
{
DbEntities db = new DbEntities();
List <ParametroScript> listParametroScript = db.ParametroScript.Where(x => x.IdScript_CondicaoScript == scriptCondicaoScript).ToList();
foreach (ParametroScript ps in listParametroScript)
{
Parametro p = db.Parametro.Where(x => x.Id == ps.IdParametro).FirstOrDefault();
ParametroValor pv = null;
if (edicao)
{
db = new DbEntities();
pv = db.ParametroValor.Where(x => x.IdTestData == idTestData && x.IdParametroScript == ps.Id).FirstOrDefault();
if (ps.VisivelEmTela)
{
pv.Valor = Request.Form.Get(p.Descricao) == null ? "" : Request.Form.Get(p.Descricao);
}
db.ParametroValor.Attach(pv);
db.Entry(pv).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
else
{
string valor = "";
switch (ps.IdParametro)
{
//EVIDENCIA AMBIENTE
case (int)EnumValoresDefault.Evidencia_Ambiente:
valor = (from psc in db.ParametroScript
where psc.IdParametro == (int)EnumValoresDefault.Ambiente_Sistema &&
psc.IdScript_CondicaoScript == scriptCondicaoScript
select psc.ValorDefault).FirstOrDefault();
if (valor == null)
{
valor = "";
}
break;
//EVIDENCIA NOME DO CASO DE TESTE
case (int)EnumValoresDefault.Evidencia_NomeDoCasoDeTeste:
string nomeCasoTeste = (from td in db.TestData
join scs in db.Script_CondicaoScript on td.IdScript_CondicaoScript equals scs.Id
join s in db.Script on scs.IdScript equals s.Id
where td.Id == idTestData
select s.Descricao
).FirstOrDefault();
string num = (from td in db.TestData
join scs in db.Script_CondicaoScript on td.IdScript_CondicaoScript equals scs.Id
join s in db.Script on scs.IdScript equals s.Id
where td.Id == idTestData
select td.CasoTesteRelativo
).FirstOrDefault();
if (num == null || nomeCasoTeste == null)
{
valor = "";
}
else
{
valor = num + " - " + nomeCasoTeste;
}
break;
//EVIDENCIA RESULTADO ESPERADO
case (int)EnumValoresDefault.Evidencia_ResultadoEsperado:
string nomeCT = "CASO DE TESTE ";
nomeCT += (from td in db.TestData
join scs in db.Script_CondicaoScript on td.IdScript_CondicaoScript equals scs.Id
join s in db.Script on scs.IdScript equals s.Id
where td.Id == idTestData
select s.Descricao
).FirstOrDefault();
nomeCT += " REALIZADO(A) COM SUCESSO!";
valor = nomeCT;
if (valor == null)
{
valor = "";
}
break;
//EVIDENCIA NUMERO CASO DE TESTE
case (int)EnumValoresDefault.Evidencia_NumeroCasoTeste:
valor = (from td in db.TestData
join scs in db.Script_CondicaoScript on td.IdScript_CondicaoScript equals scs.Id
join s in db.Script on scs.IdScript equals s.Id
where td.Id == idTestData
select td.CasoTesteRelativo
).FirstOrDefault();
if (valor == null)
{
valor = "";
}
break;
//EVIDENCIA TITULO
case (int)EnumValoresDefault.Evidencia_Titulo:
string titulo = (from td in db.TestData
join d in db.DataPool on td.IdDataPool equals d.Id
join de in db.Demanda on d.IdDemanda equals de.Id
where td.Id == idTestData && td.IdScript_CondicaoScript == scriptCondicaoScript
select d.Descricao
).First();
valor = titulo;
if (valor == null)
{
valor = "";
}
break;
//EVIDENCIA PRJ
case (int)EnumValoresDefault.Evidencia_Prj:
string prj = (from td in db.TestData
join d in db.DataPool on td.IdDataPool equals d.Id
join de in db.Demanda on d.IdDemanda equals de.Id
where td.Id == idTestData && td.IdScript_CondicaoScript == scriptCondicaoScript
select de.Descricao
).First();
valor = prj;
if (valor == null)
{
valor = "";
}
break;
//EVIDENCIA AUTOR
case (int)EnumValoresDefault.Evidencia_Autor:
string autor = (from td in db.TestData
join d in db.DataPool on td.IdDataPool equals d.Id
join de in db.Demanda on d.IdDemanda equals de.Id
where td.Id == idTestData && td.IdScript_CondicaoScript == scriptCondicaoScript
select td.GeradoPor
).First();
valor = autor;
if (valor == null)
{
valor = "";
}
break;
//EVIDENCIA FASE
case (int)EnumValoresDefault.Evidencia_Fase:
string fase = (from td in db.TestData
join d in db.DataPool on td.IdDataPool equals d.Id
join de in db.Demanda on d.IdDemanda equals de.Id
where td.Id == idTestData && td.IdScript_CondicaoScript == scriptCondicaoScript
select de.Descricao
).First();
valor = fase;
if (valor == null)
{
valor = "";
}
break;
// DEFAULT
default:
valor = Request.Form.Get(p.Descricao) == null ? "" : Request.Form.Get(p.Descricao);
break;
}
pv = new ParametroValor
{
IdParametroScript = ps.Id,
IdTestData = idTestData,
Valor = valor
};
db.ParametroValor.Add(pv);
db.SaveChanges();
}
}
}
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));
}
}
}
}
