protected void lkbPesquisarCalculo_Click(object sender, EventArgs e)
{
VariavelBLL oVariavel = new VariavelBLL();
Variavel dadosVariavel = new Variavel();
TipoOperadorCalculoBLL oTipoOperador = new TipoOperadorCalculoBLL();
dadosVariavel.Modelo = new Modelo()
{
IDModelo = Convert.ToInt32(ddlModelo.SelectedValue)
};
dadosVariavel.LinhaNegocio = ((Usuario)HttpContext.Current.Session["UsuarioLogado"]).LinhaNegocio;
dadosVariavel.IDVariavel = Convert.ToInt32(txtIdVariavel.Text);
ddlVariavelSelecionada.DataSource = oVariavel.ListarRelacao(dadosVariavel);
ddlVariavelSelecionada.DataTextField = "Descricao";
ddlVariavelSelecionada.DataValueField = "IdFilho";
ddlVariavelSelecionada.DataBind();
ddlVariavelSelecionada.Items.Insert(0, "");
ddlVariavelSelecionada.SelectedIndex = 0;
ddlOperador.DataSource = oTipoOperador.Listar();
ddlOperador.DataValueField = "IDTipoOperadorCalculo";
ddlOperador.DataTextField = "Simbolo";
ddlOperador.DataBind();
ddlOperador.Items.Insert(0, "");
ddlOperador.SelectedIndex = 0;
txtCodigoVariavel.Text = txtCodigo.Text;
txtNomeVariavel.Text = txtDescricao.Text;
mdlCalculo.Show();
}
public void loopVariavel(ICaller caller, int id)
{
Variavel v = tradeSystem.vm.GetVariavel(id);
v.reset();
while (!v.hasEnded())
{
Utils.Info("loop da variavel " + v.name + " com vlr:" + v.vlrAtual);
if (id + 1 < tradeSystem.vm.Count)
{
loopVariavel(caller, id + 1);
}
else
{
countLoops_++;
runMonteCarlo(caller, getVarsValues());
}
v.next();
//runSingleBackTest();
}
}
protected void lkbSalvarVariavel_Click(object sender, EventArgs e)
{
List <Variavel> dadosVariavelLista = new List <Variavel>();
VariavelBLL oVariavel = new VariavelBLL();
Variavel dadosVariavel = new Variavel();
dadosVariavel.Modelo = new Modelo()
{
IDModelo = Convert.ToInt32(ddlModelo.SelectedValue)
};
dadosVariavel.LinhaNegocio = ((Usuario)HttpContext.Current.Session["UsuarioLogado"]).LinhaNegocio;
dadosVariavelLista = (List <Variavel>)HttpContext.Current.Session["ListaVariavel"];
try
{
oVariavel.Persistir(dadosVariavelLista);
dadosVariavelLista = oVariavel.ListarLinhaNegocioModelo(dadosVariavel);
trvVariavel.Nodes[0].ChildNodes.Clear();
for (int i = 0; i < dadosVariavelLista.Count; i++)
{
Swap(trvVariavel.Nodes[0], dadosVariavelLista[i]);
//TreeNode tnVariavel = new TreeNode();
//tnVariavel.Value = dadosVariavelLista[i].IDVariavel.ToString();
//tnVariavel.Text = string.Concat(dadosVariavelLista[i].Codigo, " - ", dadosVariavelLista[i].Descricao);
//trvVariavel.Nodes[0].ChildNodes.Add(tnVariavel);
}
HttpContext.Current.Session["ListaVariavel"] = dadosVariavelLista;
LimpaCampos();
}
catch (Exception)
{
throw;
}
}
protected void Swap(TreeNode node, Variavel valor)
{
if (valor.IdPai == 0)
{
node.ChildNodes.Add((new TreeNode(valor.Codigo + " - " + valor.Descricao, valor.IDVariavel.ToString())));
}
else
{
if (node.ChildNodes.Count > 0)
{
foreach (TreeNode child in node.ChildNodes)
{
if (child.Value == valor.IdPai.ToString())
{
child.ChildNodes.Add(new TreeNode(valor.Codigo + " - " + valor.Descricao, valor.IDVariavel.ToString()));
return;
}
else
{
Swap(child, valor);
}
}
}
else
{
if (node.Value == valor.IdPai.ToString())
{
node.ChildNodes.Add(new TreeNode(valor.Codigo + " - " + valor.Descricao, valor.IDVariavel.ToString()));
return;
}
return;
}
}
}
private void EscreverColumns()
{
Variavel varRest = null;
_builder.AppendLine("COLUMNS");
foreach (var variavel in _funcao.Variaveis.Values)
{
//sempre escrever valor da funcao de custo
EscreverValorColumn(NOME_FUNCAO_CUSTO, variavel);
foreach (var rest in _funcao.Restricoes.Values)
{
varRest = rest.Variaveis.Values.FirstOrDefault(m => m.Nome.Equals(variavel.Nome));
if (varRest != null)
{
EscreverValorColumn(rest.Nome, varRest);
}
}
//finaliza a linha caso esteja no meio da segunda coluna
if (_segundaColunaFlag)
{
_builder.AppendLine();
_segundaColunaFlag = false;
}
}
}
public String getVarsValues()
{
String s = "";
for (int i = 0; i < tradeSystem.vm.Count; i++)
{
Variavel v = tradeSystem.vm.GetVariavel(i);
s = s + " v(" + v.name + "):" + v.vlrAtual;
}
return(s);
}
private void UpdateUI(int selectedVar)
{
Variavel var = currentVar;
frmPrincipal.SetText("txtVarName", var.name);
frmPrincipal.SetText("txtVarDescricao.", var.descricao);
frmPrincipal.SetText("txtVarVlrInicial", var.vlrInicial.ToString());
frmPrincipal.SetText("txtVarVlrFinal", var.vlrFinal.ToString());
frmPrincipal.SetText("txtVarSteps", var.steps.ToString());
frmPrincipal.SetText("labelVarId", var.uniqueID.ToString());
}
private void EscreverValorColumn(string nomeFuncao, Variavel variavel)
{
if (!_segundaColunaFlag)
{
_builder.Append(string.Concat(ESPACO_CURTO, variavel.Nome, ESPACO_CURTO, nomeFuncao, ESPACO_LONGO, variavel.Coeficiente));
}
else
{
_builder.AppendLine(string.Concat(ESPACO_CURTO, nomeFuncao, ESPACO_LONGO, variavel.Coeficiente));
}
_segundaColunaFlag = !_segundaColunaFlag;
}
public Variavel GetVariavel(string name, string descricao, float vlrInicial, int steps, float vlrFinal)
{
name = name.ToUpper();
Variavel var = GetVariavel(name);
if (var == null)
{
var = new Variavel(name, vlrInicial, steps, vlrFinal);
var.descricao = descricao;
variaveis.Add(var);
}
return(var);
}
/// <summary>
/// Retorna o Output Global da lista gerado por Modelo/ClasseVariavel
/// </summary>
/// <param name="entidade"></param>
/// <returns></returns>
public Variavel RetornaOutpuGlobal(List <Variavel> entidade)
{
var variavel = new Variavel();
foreach (Variavel Listavarivael in entidade)
{
if (Listavarivael.TipoSaida.IDTipoSaida == 3)
{
variavel = Listavarivael;
break;
}
}
return(variavel);
}
private Comando ConfigValorElemento(Comando cmd)
{
switch (cmd.TipoValorElemento)
{
case ConstValorElementoTipo.VARIAVEL:
Variavel variavel = Variaveis.FirstOrDefault(e => e.Nome == cmd.ValorElemento);
cmd.ValorElemento = variavel.Valor;
break;
default:
break;
}
return(cmd);
}
/// <summary>
/// Metodo testa todas as variaveis filho e busca seus criterios
/// </summary>
/// <param name="entidade"></param>
/// <returns></returns>
public Criterio RetornaCriterio(Variavel entidadeVariavel, Entidade entidade)
{
EntidadeBLL oEntidade = new EntidadeBLL();
VariavelCalculoVariavelBLL oCalculoVariavel = new VariavelCalculoVariavelBLL();
VariavelBLL oVariavel = new VariavelBLL();
Criterio dadosCriterio = new Criterio();
Variavel dadosVariavelLista = new Variavel();
//Retorna lista de filhos das variáveis
//dadosVariavelLista = oVariavel.ListarRelacao(entidadeVariavel);
for (int i = 0; i < dadosVariavelLista.VariavelFilho.Count; i++)
{
//Variavel com Tipo de dado Importado
if (dadosVariavelLista.VariavelFilho[i].TipoDadoVariavel.IDTipoDadoVariavel == 1)
{
entidade.Variavel.IDVariavel = dadosVariavelLista.VariavelFilho[i].IDVariavel;
entidade = oEntidade.ListarVariavel(entidade);
if (entidade.Variavel.Criterio.IDCriterio != 0)
{
dadosVariavelLista.VariavelFilho[i].Criterio.IDCriterio = entidade.Variavel.Criterio.IDCriterio;
}
else
{
dadosVariavelLista.VariavelFilho[i].Criterio.Valor = entidade.Variavel.Criterio.Valor;
}
}
//Variavel com Tipo de dado Deduzido ou Calculado
else
{
//Recursivamente Procura Filhos e seus criterios ou valores
dadosVariavelLista.VariavelFilho[i].Criterio = RetornaCriterio(dadosVariavelLista.VariavelFilho[i], entidade);
}
}
//Variavel com Tipo de dado Calculo
if (entidadeVariavel.TipoDadoVariavel.IDTipoDadoVariavel == 3)
{
//retorna o critério Utilizando o Calculo das variaveis filhas
dadosCriterio = CalculaVariavel(dadosVariavelLista.VariavelFilho, entidadeVariavel);
}
//Variavel com Tipo de dado Deduzido
else
{
//Retorna o criterio Utilizando a RegraLogica com base nos critérios das variaveis filhas
dadosCriterio = TestaRegraLogica(dadosVariavelLista.VariavelFilho, entidadeVariavel);
}
return(dadosCriterio);
}
/// <summary>
/// Verifica se Tipo de Saída possui divergencia com entidades Pai e/ou Filho
/// </summary>
/// <param name="entidade"></param>
public void ValidaTipoSaida(List <Variavel> entidade, Variavel entidadeAdd)
{
if (entidadeAdd.TipoSaida.IDTipoSaida != 3)
{
for (int j = 0; j < entidade.Count; j++)
{
if (entidade[j].IDVariavel == entidadeAdd.IdPai)
{
if (entidade[j].TipoSaida.IDTipoSaida == 3 && entidadeAdd.TipoSaida.IDTipoSaida == 1)
{
throw new Exceptions.VariavelInvalida("Variáveis com tipo de saída \"VARIÁVEL\", não podem estar ligadas, diretamente, a um \"Output Global\".");
}
}
}
}
}
public static void EX1()
{
Variavel A = new Variavel("A");
Variavel B = new Variavel("B");
Variavel C = new Variavel("C");
AbstractExpression soma = new SomarExpression(A, new SomarExpression(B, C));
Contexto contexto = new Contexto();
contexto.Assign(A, 5);
contexto.Assign(B, 15);
contexto.Assign(C, 5);
Console.WriteLine(soma.Interpret(contexto));
}
public ActionResult ExcluirVar(int ID)
{
Variavel Variavel = dbSE.Variaveis.Where(o => o.ID == ID).SingleOrDefault();
dbSE.VarBase.RemoveRange(Variavel.Base);
try
{
dbSE.SaveChanges();
return(Redirect(Request.UrlReferrer.ToString()));
}
catch (Exception)
{
return(Redirect(Request.UrlReferrer.ToString()));
}
}
/// <summary>
/// Metodo testa a regra lógica a fim de enquadrar a atual variavel em um critério
/// </summary>
/// <param name="entidadeFilha"></param>
/// <param name="entidade"></param>
/// <returns></returns>
public Criterio TestaRegraLogica(List <Variavel> entidadeFilha, Variavel entidade)
{
RegraLogicaBLL oRegraLogica = new RegraLogicaBLL();
List <RegraLogica> dadosRegraLogicaLista = new List <RegraLogica>();
RegraLogica dadosRegraLogica = new RegraLogica();
Criterio dadosCriterio = new Criterio();
MapeamentoCriterioRegraLogica dadosMapeamento = new MapeamentoCriterioRegraLogica();
MapeamentoCriterioRegraLogicaBLL oMapeamento = new MapeamentoCriterioRegraLogicaBLL();
dadosRegraLogica.Variavel = entidade;
//carrega todas as regras logicas da variavel pai
dadosRegraLogicaLista = oRegraLogica.ListarPorVariavel(dadosRegraLogica);
//percorre a lista de regra logica até encontrar a regra válida
for (int i = 0; i < dadosRegraLogicaLista.Count; i++)
{
for (int j = 0; j < entidadeFilha.Count; j++)
{
entidadeFilha[j].RegraLogica.IdRegraLogica = dadosRegraLogicaLista[i].IdRegraLogica;
//testa Variaveis para encontrar a regra lógica válida
entidadeFilha[j].RegraLogica = oRegraLogica.ValidarVariavel(entidadeFilha[j]);
//Regra Lógica falsa interrompe o laço
if (entidadeFilha[j].RegraLogica.Valido == false)
{
break;
}
//Regra lógica válida prepara o critério para retorno
else if (j + 1 == entidadeFilha.Count)
{
if (dadosRegraLogicaLista[i].VariavelHerdado.IDVariavel == 0)
{
dadosCriterio.IDCriterio = dadosRegraLogicaLista[i].Criterio.IDCriterio;
}
else
{
//Consome o Critério Original
dadosMapeamento.IdCriterioOriginal = Convert.ToInt32(dadosRegraLogicaLista[i].Criterio.IDCriterio);
//carrega o Critério Transformado
dadosMapeamento = oMapeamento.Listar(dadosMapeamento);
dadosCriterio.IDCriterio = dadosMapeamento.IdCriterioTrasnformado;
}
return(dadosCriterio);
}
}
}
return(dadosCriterio);
}
/// <summary>
/// Gera Código para variáveis com Tipo de Saída "Output Global" e valída Duplicidade de Variáveis Globais, Chamar método na Escolha do Tipo de Saída, se Output GLobal
/// </summary>
/// <param name="entidade"></param>
/// <param name="entidadeADD"></param>
/// <returns></returns>
public string GeraCodigoOutput(List <Variavel> entidade, Variavel entidadeADD)
{
//variavel usada para retornar o Codigo
string codigo = string.Empty;
string codigoTipo = string.Empty;
ClasseVariavelBLL oClasseVariavel = new ClasseVariavelBLL();
List <ClasseVariavel> dadosClasseVariavel = new List <ClasseVariavel>();
dadosClasseVariavel = oClasseVariavel.Listar();
TipoSaidaBLL oTipoSaida = new TipoSaidaBLL();
List <TipoSaida> dadosTipoSaida = new List <TipoSaida>();
dadosTipoSaida = oTipoSaida.ListarTodos();
for (int i = 0; i < entidade.Count; i++)
{
if (entidadeADD.TipoSaida.IDTipoSaida == 3 && entidade[i].TipoSaida.IDTipoSaida == entidadeADD.TipoSaida.IDTipoSaida)
{
throw new Exceptions.VariavelInvalida("Ja existe um Output Global para este modelo, verifique: " + entidade[i].Descricao);
}
}
for (int j = 0; j < dadosClasseVariavel.Count; j++)
{
if (dadosClasseVariavel[j].IDClasseVariavel == entidadeADD.ClasseVariavel.IDClasseVariavel)
{
codigo = dadosClasseVariavel[j].Codigo;
break;
}
}
for (int l = 0; l < dadosTipoSaida.Count; l++)
{
if (dadosTipoSaida[l].IDTipoSaida == entidadeADD.TipoSaida.IDTipoSaida)
{
codigoTipo = dadosTipoSaida[l].Nome;
break;
}
}
codigo += string.Concat(Convert.ToString(codigoTipo[0]), "1");
return(codigo);
}
public void UpdateValuesFromUI()
{
Variavel var = currentVar;
if (var == null)
{
return;
}
if (var.uniqueID.ToString() == frmPrincipal.Text("labelVarId"))
{
var.name = frmPrincipal.Text("txtVarName");
var.descricao = frmPrincipal.Text("txtVarDescricao");
var.vlrInicial = float.Parse(frmPrincipal.Text("txtVarVlrInicial"));
var.vlrFinal = float.Parse(frmPrincipal.Text("txtVarVlrFinal"));
var.steps = int.Parse(frmPrincipal.Text("txtVarSteps"));
frmPrincipal.SetListItem("listTSVars", selectedVar, var);
}
}
protected void ddlModelo_SelectedIndexChanged(object sender, EventArgs e)
{
Variavel dadosVariavel = new Variavel();
VariavelBLL oVariavel = new VariavelBLL();
List <Variavel> dadosVariavelLista = new List <Variavel>();
dadosVariavel.Modelo = new Modelo()
{
IDModelo = Convert.ToInt32(ddlModelo.SelectedValue)
};
dadosVariavel.LinhaNegocio = ((Usuario)HttpContext.Current.Session["UsuarioLogado"]).LinhaNegocio;
dadosVariavelLista = oVariavel.ListarLinhaNegocioModelo(dadosVariavel);
trvVariavel.Nodes[0].ChildNodes.Clear();
for (int i = 0; i < dadosVariavelLista.Count; i++)
{
Swap(trvVariavel.Nodes[0], dadosVariavelLista[i]);
}
HttpContext.Current.Session["ListaVariavel"] = dadosVariavelLista;
}
public ActionResult Variavel(VMVar Modelo)
{
if (ModelState.IsValid)
{
Variavel var;
try
{
var = dbSE.Variaveis.Where(o => o.Nome == Modelo.Nome).Single();
}
catch (Exception)
{
var = new Variavel();
var.Nome = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(Modelo.Nome);
dbSE.Variaveis.AddOrUpdate(var);
}
VarBase referencia = new VarBase();
referencia.Variavel = var;
referencia.Base = dbSE.Bases.Where(a => a.ID == Modelo.BaseID).SingleOrDefault();
referencia.Objetivo = Modelo.Obj;
dbSE.VarBase.AddOrUpdate(referencia);
try
{
dbSE.SaveChanges();
}
catch (Exception)
{
return(RedirectToAction("Variavel/" + Modelo.BaseID));;
}
return(RedirectToAction("Variavel/" + Modelo.BaseID));
}
Modelo.Variaveis = dbSE.Variaveis.Where(o => o.Base.Select(a => a.Base.ID).Contains(Modelo.BaseID)).ToList();
return(View(Modelo));
}
private bool RunVariavel(Comando cmd, IWebElement el)
{
switch (cmd.Acao)
{
case ConstActionCommand.ACTION_SET_TEXT_VARIAVEL:
Variavel variavel = new Variavel();
variavel.Tipo = ConstVariavelTipo.COMANDO;
variavel.Valor = el.Text;
variavel.Nome = cmd.Elemento.CodigoUi;
Variaveis.Add(variavel);
break;
}
return(true);
}
public RegraLogica ValidarVariavel(Variavel entidade)
{
RegraLogica regraLogica = new RegraLogica();
SqlParameter[] parm = new SqlParameter[]
{
new SqlParameter()
{
DbType = DbType.Int32,
Direction = ParameterDirection.Input,
ParameterName = "@IdRegraLogica",
Value = entidade.RegraLogica.IdRegraLogica
},
new SqlParameter()
{
DbType = DbType.Int32,
Direction = ParameterDirection.Input,
ParameterName = "@IdVariavel",
Value = entidade.IDVariavel
},
new SqlParameter()
{
DbType = DbType.Int32,
Direction = ParameterDirection.Input,
ParameterName = "@IDCriterio",
Value = entidade.Criterio.IDCriterio
}
};
using (IDataReader reader = SqlHelper.ExecuteReader(ConfigurationManager.ConnectionStrings["Default"].ConnectionString, CommandType.StoredProcedure, "RegraLogicaValidar", parm))
{
if (reader.Read())
{
regraLogica.Valido = true;
}
}
return(regraLogica);
}
public void TestVariaveis()
{
Config config = new Config();
TradeSystem tradeSystem = new TradeSystem(config);
VariavelManager vm = tradeSystem.vm;
string na = "VAR1";
string nb = "NOME_QUALQUER";
Variavel va = vm.GetVariavel(na, "", 1, 2, 3);
Variavel vb = vm.GetVariavel(nb, "", 10, 3, 30);
string text = "%" + na + "%>%" + nb + "%";
Assert.IsTrue(vm.ReplaceVariavel(text) == "1>10", "Erro: " + vm.ReplaceVariavel(text));
va.next();
vb.next();
float vna = va.vlrAtual;
float vnb = vb.vlrAtual;
Assert.IsTrue(vm.ReplaceVariavel(text) == vna + ">" + vnb, "Erro: " + vm.ReplaceVariavel(text));
text = "%" + na + "%%" + nb + "%";
Assert.IsTrue(vm.ReplaceVariavel(text) == vna + "" + vnb, "Erro: " + vm.ReplaceVariavel(text));
}
protected void rdbVariavel_CheckedChanged(Object sender, EventArgs e)
{
RadioButton radioButton = sender as RadioButton;
GridViewRow gvRow = (GridViewRow)radioButton.NamingContainer;
List <Variavel> dadosVariavelLista = new List <Variavel>();
Variavel dadosVariavel = new Variavel();
VariavelBLL oVariavel = new VariavelBLL();
txtIdVariavelPai.Text = grvVariavel.DataKeys[gvRow.RowIndex].Values[0].ToString();
txtVariavelPai.Text = grvVariavel.DataKeys[gvRow.RowIndex].Values[1].ToString();
dadosVariavelLista = ((List <Variavel>)HttpContext.Current.Session["ListaVariavel"]);
dadosVariavel = oVariavel.GeraCodigo(dadosVariavelLista, txtIdVariavelPai.Text);
txtCodigo.Text = dadosVariavel.Codigo;
HttpContext.Current.Session["ListaVariavelFilho"] = dadosVariavel;
grvVariavel.DataSource = null;
grvVariavel.DataBind();
mdlVariavel.Hide();
uppVariavel.Update();
uppCodigo.Update();
}
protected void lkbPesquisar1_Click(object sender, EventArgs e)
{
Variavel dadosVariavel = new Variavel();
VariavelBLL oVariavel = new VariavelBLL();
dadosVariavel.Modelo = new Modelo()
{
IDModelo = Convert.ToInt32(ddlModelo.SelectedValue)
};
dadosVariavel.LinhaNegocio = ((Usuario)HttpContext.Current.Session["UsuarioLogado"]).LinhaNegocio;
if (!string.IsNullOrEmpty(txtCodigoFiltro.Text))
{
dadosVariavel.Codigo = txtCodigoFiltro.Text;
}
if (!string.IsNullOrEmpty(txtNomeFiltro.Text))
{
dadosVariavel.Descricao = txtNomeFiltro.Text;
}
grvVariavel.DataSource = oVariavel.ListarModelo(dadosVariavel);
grvVariavel.DataBind();
uppVariavel.Update();
}
protected void lkbPesquisarRegras_Click(object sender, EventArgs e)
{
CriterioBLL bizCriterio = new CriterioBLL();
Criterio criterio = new Criterio();
VariavelBLL oVariavel = new VariavelBLL();
Variavel dadosVariavel = new Variavel();
TipoOperadorCalculoBLL oTipoOperador = new TipoOperadorCalculoBLL();
dadosVariavel.Modelo = new Modelo()
{
IDModelo = Convert.ToInt32(ddlModelo.SelectedValue)
};
dadosVariavel.LinhaNegocio = ((Usuario)HttpContext.Current.Session["UsuarioLogado"]).LinhaNegocio;
dadosVariavel.IDVariavel = Convert.ToInt32(txtIdVariavel.Text);
ltbVariaveis.DataSource = oVariavel.ListarRelacao(dadosVariavel);
ltbVariaveis.DataTextField = "Descricao";
ltbVariaveis.DataValueField = "IdFilho";
ltbVariaveis.DataBind();
criterio.Variavel = new Variavel()
{
IDVariavel = Convert.ToInt32(txtIdVariavel.Text)
};
criterio.LinhaNegocio = ((Usuario)HttpContext.Current.Session["UsuarioLogado"]).LinhaNegocio;
ddlResultadoRegra.DataSource = bizCriterio.RelacaoVariavelListar(criterio);
ddlResultadoRegra.DataValueField = "IDCriterio";
ddlResultadoRegra.DataTextField = "Nome";
ddlResultadoRegra.DataBind();
ddlResultadoRegra.Items.Insert(0, "");
ddlResultadoRegra.SelectedIndex = 0;
mdlRegras.Show();
}
/// <summary>
/// Metodo gera codigo de Variavel, quando este possui "Pai", chamar este metodo no momento da escolha da Variavel Pai
/// </summary>
/// <param name="entidade"></param>
/// <param name="idPai"></param>
/// <returns></returns>
public Variavel GeraCodigo(List <Variavel> entidade, string idPai)
{
//variavel usada para retornar o Codigo
string codigo = string.Empty;
List <Variavel> dadosVariavelLista = new List <Variavel>();
VariavelBLL oVariavel = new VariavelBLL();
Variavel dadosVariavel = new Variavel();
//variaval geradora de Codigo novo
int codigoNovo = 0;
for (int i = 0; i < entidade.Count; i++)
{
if (entidade[i].IDVariavel.ToString() == idPai)
{
dadosVariavelLista = oVariavel.ListarRelacao(entidade[i]);
dadosVariavel.IdPai = Convert.ToInt32(idPai);
codigoNovo = Convert.ToInt32(entidade[i].VariavelFilho.Count) + 1 + dadosVariavelLista.Count;
dadosVariavel.Codigo = entidade[i].Codigo + "." + codigoNovo.ToString();
}
}
return(dadosVariavel);
}
public RegraLogica ValidarVariavel(Variavel entidade)
{
return(_regraLogica.ValidarVariavel(entidade));
}
protected void lkbNovaVariavel_Click(object sender, EventArgs e)
{
List <Variavel> dadosVariavelLista = new List <Variavel>();
Variavel dadosVariavel = new Variavel();
VariavelBLL oVariavel = new VariavelBLL();
if (HttpContext.Current.Session["ListaVariavelFilho"] == null)
{
HttpContext.Current.Session["ListaVariavelFilho"] = new Variavel();
}
dadosVariavelLista = (List <Variavel>)HttpContext.Current.Session["ListaVariavel"];
dadosVariavel.Usuario = (Usuario)HttpContext.Current.Session["UsuarioLogado"];
dadosVariavel.Modelo = new Modelo()
{
IDModelo = Convert.ToInt32(ddlModelo.SelectedValue)
};
dadosVariavel.LinhaNegocio = ((Usuario)HttpContext.Current.Session["UsuarioLogado"]).LinhaNegocio;
dadosVariavel.TipoDadoVariavel = new TipoDadoVariavel()
{
IDTipoDadoVariavel = Convert.ToInt32(ddlTipoDado.SelectedValue)
};
dadosVariavel.TipoSaida = new TipoSaida()
{
IDTipoSaida = Convert.ToInt32(ddlTipoSaida.SelectedValue)
};
dadosVariavel.TipoVariavel = new TipoVariavel()
{
IDTipoVariavel = Convert.ToInt32(ddlTipoVariavel.SelectedValue)
};
dadosVariavel.ClasseVariavel = new ClasseVariavel()
{
IDClasseVariavel = Convert.ToInt32(ddlClasseVariavel.SelectedValue)
};
if (ddlTipoDado.SelectedValue == "1")
{
dadosVariavel.ColunaImportacao = Convert.ToInt32(txtColunaImportacao.Text);
}
if (!string.IsNullOrEmpty(txtIdVariavelPai.Text))
{
dadosVariavel.IdPai = Convert.ToInt32(txtIdVariavelPai.Text);
}
dadosVariavel.Descricao = txtDescricao.Text;
dadosVariavel.Comentario = txtDescricao2.Text;
dadosVariavel.MetodoCientificoObtencao = txtMetodoCientifico.Text;
dadosVariavel.MetodoPraticoObtencao = txtMetodoPratico.Text;
dadosVariavel.PerguntaSistema = txtPerguntaPesquisa.Text;
dadosVariavel.InteligenciaSistemicaModelo = txtPerguntaPesquisa.Text;
try
{
if (ddlTipoSaida.SelectedValue == "3" && string.IsNullOrEmpty(txtIdVariavel.Text))
{
dadosVariavel.Codigo = oVariavel.GeraCodigoOutput(dadosVariavelLista, dadosVariavel);
}
else
{
oVariavel.ValidaTipoSaida(dadosVariavelLista, dadosVariavel);
dadosVariavel.Codigo = txtCodigo.Text;
}
if (!string.IsNullOrEmpty(txtIdVariavel.Text))
{
dadosVariavel.IDVariavel = Convert.ToInt32(txtIdVariavel.Text);
dadosVariavel.Status = 2;
for (int i = 0; i < dadosVariavelLista.Count; i++)
{
if (dadosVariavelLista[i].IDVariavel == dadosVariavel.IDVariavel)
{
dadosVariavelLista[i] = dadosVariavel;
}
}
}
else
{
dadosVariavel.Status = 1;
dadosVariavelLista.Add(dadosVariavel);
Swap(trvVariavel.Nodes[0], dadosVariavel);
dadosVariavel = (Variavel)HttpContext.Current.Session["ListaVariavelFilho"];
for (int i = 0; i < dadosVariavelLista.Count; i++)
{
if (dadosVariavelLista[i].IDVariavel == dadosVariavel.IdPai)
{
dadosVariavelLista[i].VariavelFilho.Add(dadosVariavel);
}
}
}
trvVariavel.Nodes[0].ChildNodes.Clear();
for (int i = 0; i < dadosVariavelLista.Count; i++)
{
Swap(trvVariavel.Nodes[0], dadosVariavelLista[i]);
//TreeNode tnVariavel = new TreeNode();
//tnVariavel.Value = dadosVariavelLista[i].IDVariavel.ToString();
//tnVariavel.Text = string.Concat(dadosVariavelLista[i].Codigo, " - ", dadosVariavelLista[i].Descricao);
//trvVariavel.Nodes[0].ChildNodes.Add(tnVariavel);
}
LimpaCampos();
}
catch (BLL.Exceptions.VariavelInvalida ex)
{
ClientScript.RegisterClientScriptBlock(this.GetType(), Guid.NewGuid().ToString(), "alert('" + ex.Message + "');", true);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Metodo testa o valor da variavel a fim de enquadrar em um critério
/// </summary>
/// <param name="entidadeFilha"></param>
/// <param name="entidade"></param>
/// <returns></returns>
public Criterio CalculaVariavel(List <Variavel> entidadeFilha, Variavel entidade)
{
Criterio dadosCriterio = new Criterio();
List <Criterio> dadosCriterioLista = new List <Criterio>();
CalculoVariavel dadosCalculoVariavel = new CalculoVariavel();
VariavelCalculoVariavel dadosVariavelCalculo = new VariavelCalculoVariavel();
VariavelCalculoVariavelBLL oVariavelCalculo = new VariavelCalculoVariavelBLL();
CriterioBLL oCriterio = new CriterioBLL();
dadosCriterio.Variavel = entidade;
dadosCalculoVariavel.Variavel = entidade;
//retorna todos os valores e operadores para uma expressão
dadosCalculoVariavel.VariavelCalculoVariavel = oVariavelCalculo.ListarCalculo(dadosVariavelCalculo);
//Concatena todos os valores e operadores da expressão
for (int i = 0; i < dadosCalculoVariavel.VariavelCalculoVariavel.Count; i++)
{
entidade.Expressão += dadosCalculoVariavel.VariavelCalculoVariavel[i].TipoOperadorCalculo.Simbolo;
entidade.Expressão += dadosCalculoVariavel.VariavelCalculoVariavel[i].Variavel.Criterio.Valor.ToString();
}
//Retorna o valor da expressão calculada
entidade.Criterio.Valor = Convert.ToInt32(Eval(entidade.Expressão));
//lista todas os Criterios para a variavel
dadosCriterioLista = oCriterio.ListarVariavelLista(dadosCriterio);
//Testa todas os critérios variaveis até encontrar o correto
for (int j = 0; j < dadosCriterioLista.Count; j++)
{
//Menor ou igual ao valor do critério atual (Até)
if (dadosCriterioLista[j].TipoCriterioVariavel.IDTipoCriterioVariavel == 1 &&
entidade.Criterio.Valor <= dadosCriterioLista[j].CriterioVariavel.Valor1)
{
entidade.Criterio.IDCriterio = dadosCriterioLista[j].CriterioVariavel.Criterio.IDCriterio;
break;
}
//Entre os valores do Critério atual (Entre)
else if (dadosCriterioLista[j].TipoCriterioVariavel.IDTipoCriterioVariavel == 2 &&
entidade.Criterio.Valor >= dadosCriterioLista[j].CriterioVariavel.Valor1 &&
entidade.Criterio.Valor <= dadosCriterioLista[j].CriterioVariavel.Valor2)
{
entidade.Criterio.IDCriterio = dadosCriterioLista[j].CriterioVariavel.Criterio.IDCriterio;
break;
}
//Menor que o valor do critério atual (Maior que)
else if (dadosCriterioLista[j].TipoCriterioVariavel.IDTipoCriterioVariavel == 3 &&
entidade.Criterio.Valor > dadosCriterioLista[j].CriterioVariavel.Valor1)
{
entidade.Criterio.IDCriterio = dadosCriterioLista[j].CriterioVariavel.Criterio.IDCriterio;
break;
}
//Igual ao valor do critério atual (Igual)
else if (dadosCriterioLista[j].TipoCriterioVariavel.IDTipoCriterioVariavel == 4 &&
entidade.Criterio.Valor == dadosCriterioLista[j].CriterioVariavel.Valor1)
{
entidade.Criterio.IDCriterio = dadosCriterioLista[j].CriterioVariavel.Criterio.IDCriterio;
break;
}
//Menor que o valor do criterio atual (Manor que)
else if (dadosCriterioLista[j].TipoCriterioVariavel.IDTipoCriterioVariavel == 5 &&
entidade.Criterio.Valor < dadosCriterioLista[j].CriterioVariavel.Valor1)
{
entidade.Criterio.IDCriterio = dadosCriterioLista[j].CriterioVariavel.Criterio.IDCriterio;
break;
}
}
return(dadosCriterio);
}
