示例#1
0
        public void Delete(Indicador indicador)
        {
            using (var session = NHibernateHelper.OpenSession())
            {
                ValidarVinculoComVisao(indicador, session);

                var repository = new DefaultRepository<Indicador>(session);
                repository.Delete(indicador);
            }
        }
示例#2
0
        public void Update(Indicador indicador)
        {
            using (var session = NHibernateHelper.OpenSession())
            {
                if (indicador.TipoCalculo == TipoCalculoEnum.Banco)
                    ValidarIndicadorBanco(indicador, session);

                var repository = new DefaultRepository<Indicador>(session);
                repository.Update(indicador);
            }
        }
        public IList<Movimentacao> FindByIndicadorDataUsuarioFilial(Indicador indicador, DateTime data, Usuario usuario, Filial filial)
        {
            using (var session = NHibernateHelper.OpenSession())
            {
                var listMovimentacoes = session.Query<Movimentacao>()
                    .Where(m => m.DataMovimentacao.Month == data.Month
                                && m.DataMovimentacao.Year == data.Year
                                && m.Indicador.Id == indicador.Id
                                && m.Usuario.Id == usuario.Id
                                && m.Filial.Id == filial.Id)
                    .OrderByDescending(m => m.DataMovimentacao)
                    .ToList();

                return listMovimentacoes;
            }
        }
示例#4
0
        private static void ValidarIndicadorBanco(Indicador indicador, ISession session)
        {
            var isColunasVazias = string.IsNullOrWhiteSpace(indicador.NomeColuna1
                                                            + indicador.NomeColuna2
                                                            + indicador.NomeColuna3
                                                            + indicador.NomeColuna4
                                                            + indicador.NomeColuna5);

            if (isColunasVazias)
                throw new BLLException("Nenhuma coluna foi preenchida.");

            var dbinfo = new DataBaseInfo();
            var existe = dbinfo.VerificarTabelaExiste(indicador.NomeTabela.ToUpper());

            if (!existe)
                throw new BLLException("A tabela indicada não existe.");
        }
示例#5
0
        public void Insert(Indicador indicador)
        {
            using (var session = NHibernateHelper.OpenSession())
            using (var transaction = session.BeginTransaction())
            {
                ValidarId(indicador, session);
                ValidarNome(indicador, session);

                if (indicador.TipoCalculo == TipoCalculoEnum.Banco)
                    ValidarIndicadorBanco(indicador, session);

                var repository = new DefaultRepository<Indicador>(session);

                repository.Insert(indicador);
                transaction.Commit();
            }
        }
        private Movimentacao CalcularMovimentacao(Indicador indicador, Filial filial)
        {
            double? valorMovimentacao = 0d;

            switch (indicador.TipoCalculo)
            {
                case TipoCalculoEnum.Banco:
                    valorMovimentacao = CalcularValorBanco(indicador);
                    break;
                case TipoCalculoEnum.Formula:
                case TipoCalculoEnum.Manual:
                    valorMovimentacao = null;
                    break;
            }

            if (valorMovimentacao.HasValue && valorMovimentacao == 0)
                throw new Exception("Não foi possível calcular o valor do identificador.");

            var movimentacao = CreateMovimentacao(indicador, filial, valorMovimentacao);
            return movimentacao;
        }
        public void CriarIndicadorManual()
        {
            indicador = new Indicador()
            {
                Nome = "Teste"+DateTime.Now.Millisecond,
                CodigoBRS = "TES",
                TipoCalculo = TipoCalculoEnum.Manual,
                UnidadeMedida = "m",
                NomeTabela = "",
                NomeColuna1 = "",
                NomeColuna2 = "",
                NomeColuna3 = "",
                NomeColuna4 = "",
                NomeColuna5 = "",
                Visivel = false,
                Formula = ""

            };

            var manterIndicador = new ManterIndicador();
            manterIndicador.Insert(indicador);
        }
        private Indicador GetIndicador()
        {
            var indicador = new Indicador();

            indicador.Id = Convert.ToInt32(txtId.Text);
            indicador.Nome = txtDescricao.Text;
            indicador.UnidadeMedida = txtUnidadeMedida.Text;
            indicador.CodigoBRS = txtBRS.Text;
            indicador.TipoCalculo = (TipoCalculoEnum)Convert.ToInt32(ddlTipoCalculo.SelectedValue);

            //Banco
            if (indicador.TipoCalculo == TipoCalculoEnum.Banco)
            {
                indicador.NomeTabela = txtTabela.Text.ToUpper();
                indicador.NomeColuna1 = txtColuna1.Text.ToUpper();
                indicador.NomeColuna2 = txtColuna2.Text.ToUpper();
                indicador.NomeColuna3 = txtColuna3.Text.ToUpper();
                indicador.NomeColuna4 = txtColuna4.Text.ToUpper();
                indicador.NomeColuna5 = txtColuna5.Text.ToUpper();
                indicador.Visivel = ckVisivel.Checked;
            }
            else
            {
                indicador.NomeTabela = "";
                indicador.NomeColuna1 = "";
                indicador.NomeColuna2 = "";
                indicador.NomeColuna3 = "";
                indicador.NomeColuna4 = "";
                indicador.NomeColuna5 = "";
                indicador.Visivel = true;
            }

            //Fórmula
            if (indicador.TipoCalculo == TipoCalculoEnum.Formula)
            {

                indicador.Formula = ucCalculadoraIndicadorFormula.GetFormula();
            }
            else
                indicador.Formula = "";

            return indicador;
        }
 private Movimentacao CreateMovimentacao(Indicador indicador, Filial filial, double? valor)
 {
     var movimentacao = new Movimentacao()
                            {
                                DataMovimentacao = _data,
                                Indicador = indicador,
                                Filial = filial,
                                Usuario = _usuario,
                                TipoBase = TipoBaseEnum.REA,
                                Status = StatusMovimentacaoEnum.Rascunho,
                                Valor = valor
                            };
     return movimentacao;
 }
示例#10
0
 private static void ValidarVinculoComVisao(Indicador indicador, ISession session)
 {
     var listVisoes = session.Query<Visao>().Where(v => v.Indicadores.Count(i => i.Id == indicador.Id) > 0).ToList();
     if (listVisoes.Count > 0)
         throw new BLLException("O indicador esta vinculado a uma ou mais visões, por isso não pode ser excluido.");
 }
示例#11
0
        private static void ValidarNome(Indicador indicador, ISession session)
        {
            var qdtIndicadoresComMesmoNome = session.Query<Indicador>()
                .Count(i => i.Nome.Equals(indicador.Nome));

            if (qdtIndicadoresComMesmoNome > 0)
                throw new BLLException("Esse nome já está sendo usado por outro indicador");
        }
 private void SetIndicadorFormula(Indicador indicador)
 {
     ucCalculadoraIndicadorFormula.SetFormula(indicador.Formula);
 }
 private void SetIndicadorBanco(Indicador indicador)
 {
     txtTabela.Text = indicador.NomeTabela;
     txtColuna1.Text = indicador.NomeColuna1;
     txtColuna2.Text = indicador.NomeColuna2;
     txtColuna3.Text = indicador.NomeColuna3;
     txtColuna4.Text = indicador.NomeColuna4;
     txtColuna5.Text = indicador.NomeColuna5;
     ckVisivel.Checked = indicador.Visivel;
 }
示例#14
0
 private static void ValidarId(Indicador indicador, ISession session)
 {
     if (session.Get<Indicador>(indicador.Id) != null)
         throw new BLLException("Esse id já está sendo usado por outro indicador");
 }
        private double CalcularValorBanco(Indicador indicador)
        {
            var nomeTabela = indicador.NomeTabela;
            var colunas = GetColunas(indicador);

            var dataBaseInfo = new DataBaseInfo();

            var listResult = dataBaseInfo.ObterLista(nomeTabela, colunas);

            var total = 0d;
            foreach (var result in listResult)
            {
                total += Convert.ToDouble(result);
            }

            return total;
        }
        private double CalcularIndicadorFormula(Indicador indicador)
        {
            var total = 0d;

            return total;
        }
        private IList<Movimentacao> ObterMovimentacoesDoBanco(Indicador indicador, Filial filial)
        {
            var manterMovimentacao = new ManterMovimentacao();
            var listMovimentacoes = manterMovimentacao.FindByIndicadorDataUsuarioFilial(indicador, _data, _usuario, filial);

            return listMovimentacoes;
        }
        private List<string> GetColunas(Indicador indicador)
        {
            var colunas = new List<string>();

            if (!string.IsNullOrWhiteSpace(indicador.NomeColuna1))
                colunas.Add(indicador.NomeColuna1);
            if (!string.IsNullOrWhiteSpace(indicador.NomeColuna2))
                colunas.Add(indicador.NomeColuna2);
            if (!string.IsNullOrWhiteSpace(indicador.NomeColuna3))
                colunas.Add(indicador.NomeColuna3);
            if (!string.IsNullOrWhiteSpace(indicador.NomeColuna4))
                colunas.Add(indicador.NomeColuna4);
            if (!string.IsNullOrWhiteSpace(indicador.NomeColuna5))
                colunas.Add(indicador.NomeColuna5);
            return colunas;
        }
        private void SetIndicador(Indicador indicador)
        {
            txtId.Text = indicador.Id.ToString();
            txtDescricao.Text = indicador.Nome;
            txtUnidadeMedida.Text = indicador.UnidadeMedida;
            txtBRS.Text = indicador.CodigoBRS;

            ddlTipoCalculo.SelectedValue = ((int)indicador.TipoCalculo).ToString();

            if (indicador.TipoCalculo == TipoCalculoEnum.Banco)
                SetIndicadorBanco(indicador);
            else if (indicador.TipoCalculo == TipoCalculoEnum.Formula)
                SetIndicadorFormula(indicador);

            ModificarCadastro(indicador.TipoCalculo);
        }
示例#20
0
        private double obterValorMovimentacao(Indicador indicador)
        {
            Movimentacao movimentacao = new Movimentacao();
            movimentacao.Indicador = indicador;
            movimentacao.DataMovimentacao = Convert.ToDateTime(txtMesAno.Text);
            movimentacao.Usuario = usuarioLogado;
            movimentacao.Filial = new ManterFilial().FindById(Convert.ToInt32(ddlFiliais.SelectedValue));

            //var valor = new MovimentacaoController(
            //    movimentacao.Indicador,
            //    movimentacao.DataMovimentacao,
            //    movimentacao.Usuario,
            //    movimentacao.Filial
            //    ).ObterMovimentacao().Valor;

            return 0;
        }