예제 #1
0
        public void CalculaFatorAtratividade(Modelo entidadeModelo)
        {
            double      resultado = 0;
            double      valor;
            double      peso;
            Segmento    dadosSegmento = new Segmento();
            Fator       dadosFator    = new Fator();
            FatorBLL    oFator        = new FatorBLL();
            Criterio    dadosCriterio = new Criterio();
            CriterioBLL oCriterio     = new CriterioBLL();

            //Invoca Método SegmentoListar
            dadosSegmento.Modelo = new Modelo()
            {
                IDModelo = entidadeModelo.IDModelo
            };
            dadosSegmento = Listar(dadosSegmento);

            //Encontrar os Fatores relacionados para cada indice da lista Segmento
            foreach (Segmento listSegmento in dadosSegmento.SegmentoLista)
            {
                //Invoca Método FatorSegmentoListar
                dadosFator.Segmento = new Segmento()
                {
                    IDSegmento = listSegmento.IDSegmento
                };
                dadosFator = oFator.ListarSegmento(dadosFator);

                //Encontrar o IdCriterio para cada indice da lista Fator
                foreach (Fator listFator in dadosFator.FatorFilho)
                {
                    //Invoca Método CriterioFatorListar
                    dadosCriterio.IDCriterio = listFator.Criterio.IDCriterio;
                    dadosCriterio.Fator      = new Fator()
                    {
                        IDFator = listFator.IDFator
                    };
                    dadosCriterio = oCriterio.ListarFator(dadosCriterio);
                    valor         = dadosFator.Valor;

                    //Invoca Método FatorListar
                    dadosFator.IDFator = listFator.IDFator;
                    dadosFator         = oFator.Listar(dadosFator);
                    peso = dadosFator.Peso;

                    resultado = (valor * peso) + resultado;
                }
                dadosSegmento.FatorAtratividade = Convert.ToInt32(Math.Round(resultado));
                dadosSegmento.IDSegmento        = listSegmento.IDSegmento;
                Editar(dadosSegmento);
            }
        }
예제 #2
0
        public void CalculaFatorPosicionamento(Modelo entidadeModelo, VersaoProdutoFator entidadeVersaoProdutoFator)
        {
            double                fatorPosicionamento = 0;
            Fator                 dadosFator          = new Fator();
            FatorBLL              oFator                  = new FatorBLL();
            Segmento              dadosSegmento           = new Segmento();
            Criterio              dadosCriterio           = new Criterio();
            CriterioBLL           oCriterio               = new CriterioBLL();
            VersaoProdutoFator    dadosVersaoProdutoFator = new VersaoProdutoFator();
            VersaoProdutoFatorBLL oVersaoProdutoFator     = new VersaoProdutoFatorBLL();

            //Invoca método Listar do Segmento passando os parametros recebidos
            dadosSegmento.Modelo = new Modelo()
            {
                IDModelo = entidadeModelo.IDModelo
            };
            dadosSegmento = Listar(dadosSegmento);
            //Foreach para cada IDsegmento dentro da lista SegmentoLista
            foreach (Segmento listSegmento in dadosSegmento.SegmentoLista)
            {
                //Invoca método ListarPosicionamentoSemProduto passando os parametros recebidos
                dadosFator.VersaoProdutoFator = new VersaoProdutoFator()
                {
                    IdVersaoProdutoFator = entidadeVersaoProdutoFator.IdVersaoProdutoFator
                };
                dadosFator.Modelo = new Modelo()
                {
                    IDModelo = entidadeModelo.IDModelo
                };
                dadosFator.TipoFator = new TipoFator()
                {
                    IDTipoFator = 2
                };
                dadosFator = oFator.ListarPosicionamentoSemProduto(dadosFator);
                //Foreach para cada IDFator dentro da lista FatorFilho
                foreach (Fator listFator in dadosFator.FatorFilho)
                {
                    //Invoca método ListarFator do Segmento
                    dadosSegmento.IDSegmento = listSegmento.IDSegmento;
                    dadosSegmento.Fator      = new Fator()
                    {
                        IDFator = listFator.IDFator
                    };
                    dadosSegmento = ListarFator(dadosSegmento);
                    //Foreach para lista SegmentoFator
                    foreach (SegmentoFator listSegmentoFator in dadosSegmento.SegmentoFator)
                    {
                        //Invoca Método CriterioFatorListar
                        dadosCriterio.IDCriterio = listFator.Criterio.IDCriterio;
                        dadosCriterio.Fator      = new Fator()
                        {
                            IDFator = listFator.IDFator
                        };
                        dadosCriterio = oCriterio.ListarFator(dadosCriterio);
                        //Invoca Método FatorListar
                        dadosFator.IDFator = listFator.IDFator;
                        dadosFator         = oFator.Listar(dadosFator);
                        //Variável que faz a somatória de Valor x Peso
                        fatorPosicionamento += Convert.ToInt32(dadosCriterio.Valor * dadosFator.Peso);
                        //Invoca método ListarSegmentoProdutoFatorProduto
                        dadosVersaoProdutoFator.IdVersaoProdutoFator = entidadeVersaoProdutoFator.IdVersaoProdutoFator;
                        dadosVersaoProdutoFator.Segmento             = new Segmento()
                        {
                            IDSegmento = listSegmento.IDSegmento
                        };
                        dadosVersaoProdutoFator = oVersaoProdutoFator.ListarSegmentoProdutoFatorProduto(dadosVersaoProdutoFator);
                        //Verifica se o retorno do método ListarSegmentoProdutoFatorProduto tem algum registro
                        if (dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Criterio.IDCriterio == 0)
                        {
                            //Invoca Método CriterioFatorListar
                            dadosCriterio.IDCriterio = dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Criterio.IDCriterio;
                            dadosCriterio.Fator      = new Fator()
                            {
                                IDFator = dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Fator.IDFator
                            };
                            dadosCriterio = oCriterio.ListarFator(dadosCriterio);
                            //Invoca Método FatorListar
                            dadosFator.IDFator = dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Fator.IDFator;
                            dadosFator         = oFator.Listar(dadosFator);
                            //Invoca método ListarRazaoAderenciaProdutoNivel
                            dadosSegmento.IDSegmento = listSegmento.IDSegmento;
                            dadosSegmento.ProdutoNivel.IDProdutoNivel             = dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Produto.IdProduto;
                            dadosSegmento.VersaoProdutoFator.IdVersaoProdutoFator = entidadeVersaoProdutoFator.IdVersaoProdutoFator;
                            dadosSegmento = ListarRazaoAderenciaProdutoNivel(dadosSegmento);
                            //Variável que faz a somatória de fatorPosicionamento x (Valor x Peso)
                            fatorPosicionamento += Convert.ToInt32(dadosSegmento.FatorPosicionamento * (dadosCriterio.Valor * dadosFator.Peso));
                        }
                        else
                        {
                            //Invoca Método CriterioFatorListar
                            dadosCriterio.IDCriterio = dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Criterio.IDCriterio;
                            dadosCriterio.Fator      = new Fator()
                            {
                                IDFator = dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Fator.IDFator
                            };
                            dadosCriterio = oCriterio.ListarFator(dadosCriterio);
                            //Invoca Método FatorListar
                            dadosFator.IDFator = dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Fator.IDFator;
                            dadosFator         = oFator.Listar(dadosFator);
                            //Invoca método ListarRazaoAderenciaProduto
                            dadosSegmento.IDSegmento = listSegmento.IDSegmento;
                            dadosSegmento.ProdutoNivel.IDProdutoNivel             = dadosVersaoProdutoFator.VersaoSegmentoProdutoFatorProduto.Produto.IdProduto;
                            dadosSegmento.VersaoProdutoFator.IdVersaoProdutoFator = entidadeVersaoProdutoFator.IdVersaoProdutoFator;
                            dadosSegmento = ListarRazaoAderenciaProduto(dadosSegmento);
                            //Variável que faz a somatória de fatorPosicionamento x (Valor x Peso)
                            fatorPosicionamento += Convert.ToInt32(dadosSegmento.FatorPosicionamento * (dadosCriterio.Valor * dadosFator.Peso));
                        }
                    }
                }
            }
            //Invoca método Editar da VersaoProdutoFator passando o IdVersaoProdutoFator e o fatorPosicionamento
            dadosVersaoProdutoFator.IdVersaoProdutoFator = entidadeVersaoProdutoFator.IdVersaoProdutoFator;
            dadosVersaoProdutoFator.FatorPosicionamento  = Convert.ToInt32(fatorPosicionamento);
            oVersaoProdutoFator.Editar(dadosVersaoProdutoFator);
        }
예제 #3
0
        /// <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);
        }
예제 #4
0
        public void GerarCodigoSegmento(Modelo entidadeModelo)
        {
            string          codigo;
            Modelo          dadosModelo      = new Modelo();
            TipoSegmentoBLL oTipoSegmento    = new TipoSegmentoBLL();
            Variavel        dadosVariavel    = new Variavel();
            VariavelBLL     oVariavel        = new VariavelBLL();
            Criterio        dadosCriterio    = new Criterio();
            CriterioBLL     oCriterio        = new CriterioBLL();
            RegraLogica     dadosRegraLogica = new RegraLogica();
            RegraLogicaBLL  oRegraLogica     = new RegraLogicaBLL();
            Segmento        dadosSegmento    = new Segmento();

            //Invoca Método para retornar OutputGlobal
            dadosVariavel.Modelo = new Modelo()
            {
                IDModelo = entidadeModelo.IDModelo
            };
            dadosVariavel.TipoSaida = new TipoSaida()
            {
                IDTipoSaida = 3
            };
            dadosVariavel.ClasseVariavel = new ClasseVariavel()
            {
                IDClasseVariavel = null
            };
            dadosVariavel = oVariavel.ListarOutputGlobal(dadosVariavel);
            if (dadosVariavel.IDVariavel == 0)
            {
                throw new Exceptions.RegraLogicaInvalida("NÃO EXISTE NENHUM OUTPUT GLOBAL VINCULADO A ESSE MODELO. IMPOSSÍVEL GERAR SEGMENTOS.");
            }

            //Invoca Método para retornar RegraLógica
            dadosRegraLogica.Variavel = new Variavel()
            {
                IDVariavel = dadosVariavel.IDVariavel
            };
            dadosRegraLogica = oRegraLogica.Listar(dadosRegraLogica);
            if (dadosRegraLogica.RegraLogicaLista.Count == 0)
            {
                throw new Exceptions.RegraLogicaInvalida("NÃO EXISTE NENHUMA REGRA LÓGICA VINCULADA AO OUTPUT GLOBAL DO MODELO. IMPOSSÍVEL GERAR SEGMENTOS.");
            }

            //Pegar o IdRegraLogica de cada indice da lista RegraLogica
            foreach (RegraLogica listRegraLogica in dadosRegraLogica.RegraLogicaLista)
            {
                if (listRegraLogica.IdRegraLogica == null)
                {
                    throw new Exceptions.RegraLogicaInvalida("REGRA LÓGICA NÃO CADASTRADA");
                }

                //Invoca Método para retornar o Nome Modelo.
                dadosModelo = oTipoSegmento.Listar(entidadeModelo);
                //Atribui a primeira letra do Nome Modelo no Código.
                codigo = dadosModelo.Nome[0].ToString();
                //Concatena abre colchetes no Código.
                codigo += "[";

                //Invoca Método para retornar Nome Critério.
                dadosCriterio.IDCriterio   = listRegraLogica.Criterio.IDCriterio;
                dadosCriterio.LinhaNegocio = new LinhaNegocio()
                {
                    IDLinhaNegocio = null
                };
                dadosCriterio = oCriterio.Listar(dadosCriterio);

                //Concatena as 3 primeiras Letras do Nome Critério no Código.
                codigo += dadosCriterio.Nome[0];
                codigo += dadosCriterio.Nome[1];
                codigo += dadosCriterio.Nome[2];
                //Concatena abre parenteses no Código.
                codigo += "(";

                //Invoca Método para retornar uma lista de VariavelRegraLogica.
                dadosVariavel.TipoSaida = new TipoSaida()
                {
                    IDTipoSaida = 3
                };
                dadosVariavel.Modelo = new Modelo()
                {
                    IDModelo = entidadeModelo.IDModelo
                };
                dadosVariavel.RegraLogica = new RegraLogica()
                {
                    IdRegraLogica = listRegraLogica.IdRegraLogica
                };
                dadosVariavel.ClasseVariavel = new ClasseVariavel()
                {
                    IDClasseVariavel = null
                };
                dadosVariavel = oVariavel.ListarRegraLogicaProcessoSegmento(dadosVariavel);

                //Pegar o IdCriterio de cada indice da lista VariavelRegraLogica
                foreach (VariavelRegraLogica list in dadosVariavel.VariavelRegraLogicaLista)
                {
                    //Invoca Método para retornar Nome Critério.
                    dadosCriterio.IDCriterio   = list.Criterio.IDCriterio;
                    dadosCriterio.LinhaNegocio = new LinhaNegocio()
                    {
                        IDLinhaNegocio = null
                    };
                    dadosCriterio = oCriterio.Listar(dadosCriterio);
                    //Concatena as 2 primeiras Letras do Nome Critério no Código.
                    codigo += dadosCriterio.Nome[0];
                    codigo += dadosCriterio.Nome[1] + ", ";
                }

                //Concatena fecha parenteses no Código.
                codigo += ")";
                //Concatena fecha colchetes no Código.
                codigo += "]";

                //Verifica se existe algum relacionamento com o SegmentoRegraLogica e o exclui
                dadosSegmento.Modelo = new Modelo()
                {
                    IDModelo = entidadeModelo.IDModelo
                };
                dadosSegmento = Listar(dadosSegmento);
                foreach (Segmento listSegmento in dadosSegmento.SegmentoLista)
                {
                    dadosSegmento.IDSegmento = listSegmento.IDSegmento;
                    RemoverRegraLogica(dadosSegmento);
                }
                dadosSegmento.Modelo = new Modelo()
                {
                    IDModelo = entidadeModelo.IDModelo
                };
                dadosSegmento.IDSegmento = null;
                dadosSegmento.Codigo     = null;
                dadosSegmento.Usuario    = new Usuario()
                {
                    IDUsuario = null
                };
                try
                {
                    Remover(dadosSegmento);
                }
                catch (Exception)
                {
                    throw new Exceptions.RegraLogicaInvalida("EXISTEM RELACIONAMENTOS PENDENTES PARA ESTE SEGMENTO. IMPOSSÍVEL GERAR SEGMENTOS.");
                }


                //Invoca Método para inserir o Código Segmento.
                dadosSegmento.TamanhoMercado    = null;
                dadosSegmento.Codigo            = codigo;
                dadosSegmento.FatorAtratividade = null;
                dadosSegmento.Modelo            = new Modelo()
                {
                    IDModelo = entidadeModelo.IDModelo
                };
                dadosSegmento.Usuario = new Usuario()
                {
                    IDUsuario = entidadeModelo.Usuario.IDUsuario
                };
                Novo(dadosSegmento);

                //Invoca Método para inserir a relação Segmento e RegraLógica
                dadosSegmento.RegraLogica = new RegraLogica()
                {
                    IdRegraLogica = listRegraLogica.IdRegraLogica
                };
                NovoRegraLogica(dadosSegmento);
            }
        }
예제 #5
0
        public void LerArquivoEntidade(string arquivoLocal, Modelo entidadeModelo)
        {
            string                   variavel;
            int                      idEntidade;
            Modelo                   dadosModelo = new Modelo();
            ModeloBLL                oModelo     = new ModeloBLL();
            LogImportacaoEntidade    dadosLogImportacaoEntidade = new LogImportacaoEntidade();
            LogImportacaoEntidadeBLL oLogImportacaoEntidade     = new LogImportacaoEntidadeBLL();
            Entidade                 dadosEntidade = new Entidade();
            EntidadeBLL              oEntidade     = new EntidadeBLL();
            Criterio                 dadosCriterio = new Criterio();
            CriterioBLL              oCriterio     = new CriterioBLL();

            //Atribui o CSV no StreamReader passando o local do arquivo como parâmetro
            StreamReader stream = new StreamReader(arquivoLocal);
            //Pula o Header
            string linha = stream.ReadLine();

            //Laço de cada linha
            while ((linha = stream.ReadLine()) != null)
            {
                //Quebra a linha nas colunas correspondentes que estiverem separadas por ";"
                string[] linhaSeparada = linha.Split(';');
                //Invoca método ListarVariavelImportacao passando o IdTipoDadoVariavel como importada
                dadosModelo.TipoDadoVariavel = new TipoDadoVariavel()
                {
                    IDTipoDadoVariavel = 1
                };
                dadosModelo = oModelo.ListarVariavelImportacao(entidadeModelo);
                //Foreach para ler cada ColunaImportacao na lista de ModelosVariaveis
                foreach (ModeloVariavel list in dadosModelo.ModeloVariavel)
                {
                    //Se valor informado estiver nulo no arquivo CSV, Criticar a mesma
                    if (linhaSeparada[list.Variavel.ColunaImportacao] == null)
                    {
                        dadosLogImportacaoEntidade.CodigoVariavel    = list.Variavel.Codigo;
                        dadosLogImportacaoEntidade.DocumentoEntidade = linhaSeparada[0].ToString();
                        dadosLogImportacaoEntidade.Mensagem          = "Valor de Variável não informado para a variável " + list.Variavel.IDVariavel;
                        oLogImportacaoEntidade.Novo(dadosLogImportacaoEntidade);
                    }
                    //Caso tenha conteúdo, fazer as seguintes verificações
                    else
                    {
                        //Invoca método Novo da EntidadeBLL passando as 3 primeiras colunas como parametros
                        dadosEntidade.Documento = linhaSeparada[0].ToString();
                        dadosEntidade.Nome      = linhaSeparada[1].ToString();
                        dadosEntidade.Regiao    = linhaSeparada[2].ToString();
                        dadosEntidade.Modelo    = new Modelo()
                        {
                            IDModelo = entidadeModelo.IDModelo
                        };
                        oEntidade.Novo(dadosEntidade);
                        //Atribui ao idEntidade o @@Identity do método novo
                        idEntidade = dadosEntidade.IDEntidade;
                        //Atribui a variavel o conteúdo correspondente da ColunaImportacao
                        variavel = linhaSeparada[list.Variavel.ColunaImportacao].ToString();
                        //Caso os primeiros caracteres comecem com "de"
                        if (variavel.StartsWith("de"))
                        {
                            //Quebra a Variavel para capturar os valores 1 e 2
                            string[] variavelSeparada = variavel.Split(' ');
                            //Invoca método ListarVariavel e retorna IDCriterio
                            dadosCriterio.CriterioVariavel = new CriterioVariavel()
                            {
                                Valor1 = Convert.ToInt32(variavelSeparada[1]),
                                Valor2 = Convert.ToInt32(variavelSeparada[3])
                            };
                            dadosCriterio.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosCriterio.TipoCriterioVariavel = new TipoCriterioVariavel()
                            {
                                IDTipoCriterioVariavel = 2
                            };
                            dadosCriterio = oCriterio.ListarVariavel(dadosCriterio);
                            //Invoca método NovoVariavel da EntidadeBLL
                            dadosEntidade.Criterio = new Criterio()
                            {
                                IDCriterio = dadosCriterio.IDCriterio
                            };
                            dadosEntidade.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosEntidade.IDEntidade = idEntidade;
                            oEntidade.NovoVariavel(dadosEntidade);
                        }
                        //Caso os primeiros caracteres comecem com "até"
                        else if (variavel.StartsWith("até"))
                        {
                            //Quebra a Variavel para capturar o valor 1
                            string[] variavelSeparada = variavel.Split('$');
                            //Invoca método ListarVariavel e retorna IDCriterio
                            dadosCriterio.CriterioVariavel = new CriterioVariavel()
                            {
                                Valor1 = Convert.ToDouble(variavelSeparada[1].Replace(',', '.'))
                            };
                            dadosCriterio.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosCriterio.TipoCriterioVariavel = new TipoCriterioVariavel()
                            {
                                IDTipoCriterioVariavel = 2
                            };
                            dadosCriterio = oCriterio.ListarVariavel(dadosCriterio);
                            //Invoca método NovoVariavel da EntidadeBLL
                            dadosEntidade.Criterio = new Criterio()
                            {
                                IDCriterio = dadosCriterio.IDCriterio
                            };
                            dadosEntidade.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosEntidade.IDEntidade = idEntidade;
                            oEntidade.NovoVariavel(dadosEntidade);
                        }
                        //Caso seja um valor numérico
                        else if (variavel.GetType() == typeof(Int32))
                        {
                            //Invoca método ListarVariavel e retorna IDCriterio
                            dadosCriterio.CriterioVariavel = new CriterioVariavel()
                            {
                                Valor1 = Convert.ToDouble(variavel)
                            };
                            dadosCriterio.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosCriterio.TipoCriterioVariavel = new TipoCriterioVariavel()
                            {
                                IDTipoCriterioVariavel = 2
                            };
                            dadosCriterio = oCriterio.ListarVariavel(dadosCriterio);
                            //Caso o IdCriterio não seja encontrado
                            if (dadosCriterio.IDCriterio == 0)
                            {
                                //Invoca método NovoVariavel da EntidadeBLL
                                dadosEntidade.EntidadeVariavelObject = new EntidadeVariavel()
                                {
                                    Valor = Convert.ToDouble(variavel)
                                };
                                dadosEntidade.Variavel = new Variavel()
                                {
                                    IDVariavel = list.Variavel.IDVariavel
                                };
                                dadosEntidade.IDEntidade = idEntidade;
                                oEntidade.NovoVariavel(dadosEntidade);
                            }
                            else
                            {
                                //Invoca método NovoVariavel da EntidadeBLL
                                dadosEntidade.Criterio = new Criterio()
                                {
                                    IDCriterio = dadosCriterio.IDCriterio
                                };
                                dadosEntidade.Variavel = new Variavel()
                                {
                                    IDVariavel = list.Variavel.IDVariavel
                                };
                                dadosEntidade.IDEntidade = idEntidade;
                                oEntidade.NovoVariavel(dadosEntidade);
                            }
                        }
                        //Caso os primeiros caracteres comecem com "abaixo de"
                        else if (variavel.StartsWith("abaixo de"))
                        {
                            //Quebra a Variavel para capturar o valor 1
                            string[] variavelSeparada = variavel.Split(' ');
                            //Invoca método ListarVariavel e retorna IDCriterio
                            dadosCriterio.CriterioVariavel = new CriterioVariavel()
                            {
                                Valor1 = Convert.ToDouble(variavelSeparada[3])
                            };
                            dadosCriterio.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosCriterio.TipoCriterioVariavel = new TipoCriterioVariavel()
                            {
                                IDTipoCriterioVariavel = 5
                            };
                            dadosCriterio = oCriterio.ListarVariavel(dadosCriterio);
                            //Invoca método NovoVariavel da EntidadeBLL
                            dadosEntidade.Criterio = new Criterio()
                            {
                                IDCriterio = dadosCriterio.IDCriterio
                            };
                            dadosEntidade.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosEntidade.IDEntidade = idEntidade;
                            oEntidade.NovoVariavel(dadosEntidade);
                        }
                        //Caso os primeiros caracteres comecem com "acima de"
                        else if (variavel.StartsWith("acima de"))
                        {
                            //Quebra a Variavel para capturar o valor 1
                            string[] variavelSeparada = variavel.Split(' ');
                            //Invoca método ListarVariavel e retorna IDCriterio
                            dadosCriterio.CriterioVariavel = new CriterioVariavel()
                            {
                                Valor1 = Convert.ToDouble(variavelSeparada[3])
                            };
                            dadosCriterio.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosCriterio.TipoCriterioVariavel = new TipoCriterioVariavel()
                            {
                                IDTipoCriterioVariavel = 3
                            };
                            dadosCriterio = oCriterio.ListarVariavel(dadosCriterio);
                            //Invoca método NovoVariavel da EntidadeBLL
                            dadosEntidade.Criterio = new Criterio()
                            {
                                IDCriterio = dadosCriterio.IDCriterio
                            };
                            dadosEntidade.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosEntidade.IDEntidade = idEntidade;
                            oEntidade.NovoVariavel(dadosEntidade);
                        }
                        //Caso seja uma String
                        else if (variavel.GetType() == typeof(String))
                        {
                            //Invoca método ListarVarivelImportacao e retorna IDCriterio
                            dadosCriterio.Nome     = linhaSeparada[1].ToString().Trim();
                            dadosCriterio.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosCriterio = oCriterio.ListarVariavelImportacao(dadosCriterio);
                            //Invoca método NovoVariavel da EntidadeBLL
                            dadosEntidade.Criterio = new Criterio()
                            {
                                IDCriterio = dadosCriterio.IDCriterio
                            };
                            dadosEntidade.Variavel = new Variavel()
                            {
                                IDVariavel = list.Variavel.IDVariavel
                            };
                            dadosEntidade.IDEntidade = idEntidade;
                            oEntidade.NovoVariavel(dadosEntidade);
                        }
                        //Caso não se encaixe em nenhuma das situações, Criticar
                        else
                        {
                            dadosLogImportacaoEntidade.CodigoVariavel    = list.Variavel.Codigo;
                            dadosLogImportacaoEntidade.DocumentoEntidade = linhaSeparada[0].ToString();
                            dadosLogImportacaoEntidade.Mensagem          = "Domínio informado para a variável " + list.Variavel.IDVariavel + " e Coluna Importação " + variavel + "inexistente no software segmentação";
                            oLogImportacaoEntidade.Novo(dadosLogImportacaoEntidade);
                        }
                    }
                }
            }
            //Fecha a conexão do Stream
            stream.Close();
        }