public void CalcularReceitaBrutaOrcamentoHospitalarCOmUmSetorComDuasContasEContaDeQuantidadeEUmaDePorcentagemEvalorDaContaEmJaneiroIgualAUmEporcentagemIgualACinquentaEUnitarioIgualACemEValorComplexidadeIgualA10PorCentoValorReceitaLiuidaDeveSerIgualACentoEDez()
        {
            Departamento departamento = new Hospital("Barra Dor");
            var Uti = new SetorHospitalar("UTI");
            var SubUtiAdulto = new SubSetorHospital("UTIAdulto");
            ContaHospital leito = new ContaHospital("Leito", TipoValorContaEnum.Quantidade);
            ContaHospital ocupacao = new ContaHospital("Ocupação", TipoValorContaEnum.Porcentagem);
            leito.MultiPlicaPorMes = true;

            Uti.AdicionarSetor(SubUtiAdulto);
            Uti.AdicionarConta(leito);
            Uti.AdicionarConta(ocupacao);

            departamento.AdicionarSetor(Uti);

            OrcamentoHospitalar orcamento = new OrcamentoHospitalar(departamento, 2014);

            var leitoProducao = orcamento.Servicos.FirstOrDefault().Valores.Where(v => v.Mes == MesEnum.Janeiro).FirstOrDefault();

            var ocupacaoProducao = orcamento.Servicos[1].Valores.Where(v => v.Mes == MesEnum.Janeiro).FirstOrDefault();

            leitoProducao.Valor = 1;
            ocupacaoProducao.Valor = 50;

            var incremento = orcamento.FatoresReceita.FirstOrDefault().Incrementos.Where(i => i.Mes == MesEnum.Janeiro).FirstOrDefault();
            incremento.Ticket = 100;

            orcamento.CalcularReceitaBruta(Tickets(100, orcamento));

            Assert.IsTrue(incremento.ReceitaBruta == 1550);
        }
        public void CalcularReceitaBrutaOrcamentoHospitalarCOmUmSetorComUmaContaEContaDeQuantidadeEvalorDaContaEmJaneiroIgualADoisEUnitarioIgualAQuinhentosValorReceitaBrutaDeveSerIgualAMil()
        {
            Departamento departamento = new Hospital("Barra Dor");
            var CentroCirurgico = new SetorHospitalar("Cirurgia");
            var SubCentroCirurgico = new SubSetorHospital("Centro Cirúrgico");
            ContaHospital Cirurgia = new ContaHospital("Cirurgia", TipoValorContaEnum.Quantidade);

            CentroCirurgico.AdicionarSetor(SubCentroCirurgico);
            CentroCirurgico.AdicionarConta(Cirurgia);

            departamento.AdicionarSetor(CentroCirurgico);

            OrcamentoHospitalar orcamento = new OrcamentoHospitalar(departamento, 2014);

            var producaoHospitalar = orcamento.Servicos.FirstOrDefault().Valores.Where(v => v.Mes == MesEnum.Janeiro).FirstOrDefault();

            producaoHospitalar.Valor = 2;

            var incremento = orcamento.FatoresReceita.FirstOrDefault().Incrementos.Where(i => i.Mes == MesEnum.Janeiro).FirstOrDefault();
            incremento.Ticket = 500;

            orcamento.CalcularReceitaBruta(Tickets(500, orcamento));

            Assert.IsTrue(incremento.ReceitaBruta == 1000);
        }
        // [Test]
        public void AoCriarPrimeiroOrcamentoNomeDeveSerIgualAVersaoUm()
        {
            GerenciadorDeOrcamentos gerenciamento = new GerenciadorDeOrcamentos();
            Departamento departamento = new Hospital("Barra Dor");
            var orcamento = new OrcamentoHospitalar(departamento, 2012);
            gerenciamento.InformarNomeOrcamento(new List<Orcamento.Domain.Orcamento>(), orcamento, departamento, TipoOrcamentoEnum.Hospitalar);

            Assert.IsTrue(orcamento.NomeOrcamento == "Versão 1");
        }
 public void AoCriarSegundoOrcamentoNomeDeveSerIgualAVersaoDois()
 {
     Departamento departamento = new Hospital("Barra Dor");
     var orcamento = new OrcamentoHospitalar(departamento, 2012);
     var listaOrcamentos = new List<Orcamento.Domain.Orcamento>();
     listaOrcamentos.Add(orcamento);
     GerenciadorDeOrcamentos gerenciamento = new GerenciadorDeOrcamentos();
     gerenciamento.InformarNomeOrcamento(listaOrcamentos, orcamento, departamento, TipoOrcamentoEnum.Hospitalar);
     Assert.IsTrue(orcamento.NomeOrcamento == "Versão 2");
 }
        public void AtribuirVersaoFinalComSucesso()
        {
            ServicoCriarOrcamentoHospitalar servico = new ServicoCriarOrcamentoHospitalar();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            orcamentos.Expect(o => o.ObterOrcamentoHospitalarFinal(null)).IgnoreArguments().Return(null);
            servico.Orcamentos = orcamentos;
            Departamento departamento = new Hospital("Barra dor");

            var orcamento = new OrcamentoHospitalar(departamento, 2014);
            servico.AtribuirVersaoFinal(orcamento);

            Assert.IsTrue(orcamento.VersaoFinal);
        }
        public void AtribuirVersaoFinalComSucesso()
        {
            ServicoOrcamentoDeViagens servico = new ServicoOrcamentoDeViagens();

            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();

            var diarias = MockRepository.GenerateMock<IDiarias>();

            Diaria diaria = new Diaria();
            diaria.Cidade = new Cidade("ljk") {Descricao = "kjh"};
            Ticket ticket = new Ticket(new TipoTicket("1"), diaria.Cidade);
            ticket.Valor = 10;

            diaria.Tickets = new List<Ticket>();
            diaria.Tickets.Add(ticket);

            List<Diaria> listaDiarias = new List<Diaria>();

            listaDiarias.Add(diaria);

            diarias.Expect(c => c.Todos()).Return(listaDiarias);

            var viagens = MockRepository.GenerateMock<IViagens>();
            viagens.Expect(c => c.Todos()).Return(new List<Viagem>());

            servico.Orcamentos = orcamentos;
            servico.Diarias = diarias;
            servico.Viagens = viagens;

            Departamento departamento = new Hospital("Barra dor");

            var orcamento = new OrcamentoDeViagem(departamento, new CentroDeCusto("centroDeCusto"), 2014);

            DiariaViagem despesa = new DiariaViagem();
            despesa.ValorTotal = 10;
            despesa.Diaria = diaria;
            orcamento.Despesas.Add(despesa);

            servico.AtribuirVersaoFinal(orcamento);

            Assert.IsTrue(orcamento.VersaoFinal);
        }
        public void CriarOrcamentoComSucessoComCincoOrcamentoJaCriadoDeveTeNomeOrcamentoIgualAVersaoSeis()
        {
            ServicoCriarOrcamentoHospitalar servico = new ServicoCriarOrcamentoHospitalar();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            servico.Orcamentos = orcamentos;

            Departamento departamento = new Hospital("Barra dor");

            var orcamentosLista = new List<Orcamento.Domain.Orcamento>();
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            var orcamento = servico.CriarOrcamentoHospitalar(orcamentosLista, departamento, 2014);

            Assert.AreEqual(orcamento.NomeOrcamento, "Versão6");
        }
        public void AtribuirVersaoFinalComSucesso()
        {
            ServicoOrcamentoOperacionalVersao servico = new ServicoOrcamentoOperacionalVersao();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            orcamentos.Expect(o => o.ObterOrcamentoFinalOrcamentoOperacional(null,null)).IgnoreArguments().Return(null);
            servico.Orcamentos = orcamentos;
            Departamento departamento = new Hospital("Barra dor");

            var orcamento = new OrcamentoOperacionalVersao(departamento, new CentroDeCusto("centroDeCusto"), 2014);

            Despesa despesa = new Despesa(MesEnum.Janeiro, null);
            despesa.Valor = 10;

            orcamento.DespesasOperacionais.Add(despesa);

            servico.AtribuirVersaoFinal(orcamento);

            Assert.IsTrue(orcamento.VersaoFinal);
        }
        public void CriarOrcamentoComSucessoComDezDeveRetornarExecao()
        {
            ServicoCriarOrcamentoHospitalar servico = new ServicoCriarOrcamentoHospitalar();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            servico.Orcamentos = orcamentos;

            Departamento departamento = new Hospital("Barra dor");

            var orcamentosLista = new List<Orcamento.Domain.Orcamento>();
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            var orcamento = servico.CriarOrcamentoHospitalar(orcamentosLista, departamento, 2014);
        }
        public void c_integrar_dados_do_excel_test()
        {
            var tiposConta = new TiposConta();

            var tipoContaOutras = new TipoConta { Nome = "Outras" };

            tiposConta.Adicionar(tipoContaOutras);

            string _conectionstring;
            _conectionstring = @"Provider=Microsoft.Jet.OLEDB.4.0;";
            _conectionstring += String.Format("Data Source={0};", "D:\\Hospital2.xls");
            _conectionstring += "Extended Properties='Excel 8.0;HDR=NO;'";

            OleDbConnection cn = new OleDbConnection(_conectionstring);
            OleDbCommand cmd = new OleDbCommand("Select * from [HOSPITAL x CENTRO CUSTO MOD$]", cn);
            cn.Open();
            OleDbDataReader reader = cmd.ExecuteReader();

            List<RegistroExcel> documento = new List<RegistroExcel>();

            List<Conta> listaContas = new List<Conta>();
            List<CentroDeCusto> listaCentrosDeCusto = new List<CentroDeCusto>();

            Hospitais repositorioDeHospitais = new Hospitais();
            CentrosDeCusto repositorioDeCusto = new CentrosDeCusto();
            Contas repositorioContas = new Contas();

            int i = 0;

            while (reader.Read())
            {
                if (i == 0)
                {
                    i++;
                    continue;
                }
                if (reader[0] == DBNull.Value)
                    break;

                RegistroExcel registroExcel = new RegistroExcel()
                {
                    NomeHospital = (string)reader[0],
                    CodigoCentroDeCusto = (string)reader[1],
                    DescricaoCentroDeCusto = (string)reader[2]
                };

                if (reader[3] != DBNull.Value)
                {
                    registroExcel.DescricaoConta = (string)reader[3];
                    registroExcel.CodigoConta = (string)reader[4];
                    registroExcel.GrupoResumoNome = (string)reader[5];
                }

                documento.Add(registroExcel);
            }

            cn.Close();
            cn.Dispose();
            cmd.Dispose();

            var gruposDeConta = documento.Select(x => x.GrupoResumoNome).Distinct();

            var codigosDeConta = documento.Select(x => x.CodigoConta).Distinct();

            foreach (var codigoDeConta in codigosDeConta)
            {
                string descricaoDaConta = documento.Where(x => x.CodigoConta == codigoDeConta).Select(y => y.DescricaoConta).Distinct().First();

                Conta conta;
                if (!listaContas.Any(c => c.CodigoDaConta == codigoDeConta))
                {
                    conta = new Conta(descricaoDaConta, tipoContaOutras)
                    {
                        CodigoDaConta = codigoDeConta
                    };
                    repositorioContas.Salvar(conta);
                    listaContas.Add(conta);
                }
                else
                    conta = listaContas.Where(c => c.CodigoDaConta == codigoDeConta).FirstOrDefault();

            }
            GruposDeConta grupos = new GruposDeConta();
            List<GrupoDeConta> gruposDeContaLista = new List<GrupoDeConta>();
            foreach (var grupo in gruposDeConta)
            {
                GrupoDeConta grupoDeConta = new GrupoDeConta(grupo);

                var contasDoGrupo = documento.Where(x => x.GrupoResumoNome == grupo).Select(y => y.CodigoConta).Distinct();

                foreach (var codigoConta in contasDoGrupo)
                {
                    var conta = listaContas.Where(c => c.CodigoDaConta == codigoConta).FirstOrDefault();

                    grupoDeConta.Adicionar(conta);
                }

                gruposDeContaLista.Add(grupoDeConta);
                grupos.Salvar(grupoDeConta);
            }

            var codigosDecentrosDeCusto = documento.Select(x => x.CodigoCentroDeCusto).Distinct();

            foreach (var codigoDeCentro in codigosDecentrosDeCusto)
            {
                var descricaoDeCentroDeCusto = documento.Where(x => x.CodigoCentroDeCusto == codigoDeCentro).Select(y => y.DescricaoCentroDeCusto).Distinct().First();

                CentroDeCusto centroDeCusto = new CentroDeCusto(descricaoDeCentroDeCusto)
                {
                    CodigoDoCentroDeCusto = codigoDeCentro
                };

                var contas = documento.Where(x => x.CodigoCentroDeCusto == codigoDeCentro).Select(y => y.CodigoConta).Distinct();

                foreach (var conta in contas)
                {
                    centroDeCusto.AdicionarConta(listaContas.Where(x => x.CodigoDaConta == conta).SingleOrDefault());
                }

                repositorioDeCusto.Salvar(centroDeCusto);
                listaCentrosDeCusto.Add(centroDeCusto);
            }

            var hospitais = documento.Select(x => x.NomeHospital).Distinct();

            foreach (var nomeHospital in hospitais)
            {
                Hospital hospital = new Hospital();

                hospital.Nome = nomeHospital;

                var centrosDeCusto = documento.Where(x => x.NomeHospital == hospital.Nome).Select(y => y.CodigoCentroDeCusto).Distinct();

                foreach (var codigoCentroCusto in centrosDeCusto)
                {
                    hospital.AdicionarCentroDeCusto(listaCentrosDeCusto.Where(x => x.CodigoDoCentroDeCusto == codigoCentroCusto).SingleOrDefault());
                }

                repositorioDeHospitais.Salvar(hospital);
            }
        }
        private static void CriarContaComCentroDeCustoEncontrado(Hospitais hospitais, DataRow row, Hospital hospital, CentroDeCusto centroDeCusto)
        {
            Conta conta = centroDeCusto.ObterContaPor((string)row[4]);

            if (conta == null)
            {
                Contas contas = new Contas();

                conta = contas.ObterContaPor(codigo: (string)row[4]);

                if (conta == null)
                {
                    conta = new Conta(nome: (string)row[3]);

                    conta.CodigoDaConta = (string)row[4];

                    centroDeCusto.AdicionarConta(conta);
                }
                else
                {
                    centroDeCusto.AdicionarConta(conta);
                }
            }

            hospital.Remover(centroDeCusto);
            hospital.Adicionar(centroDeCusto);
            hospitais.Adicionar(hospital);
        }
        public void CriarOrcamentoHospitalarComUmSetorComUmaContaDeveTeServicosHospitalaresIgualAUm()
        {
            Departamento departamento = new Hospital("Barra Dor");
            var CentroCirurgico = new SetorHospitalar("Cirurgia");
            var SubCentroCirurgico = new SubSetorHospital("Centro Cirúrgico");
            ContaHospital Cirurgia = new ContaHospital("Cirurgia", TipoValorContaEnum.Quantidade);

            CentroCirurgico.AdicionarSetor(SubCentroCirurgico);
            CentroCirurgico.AdicionarConta(Cirurgia);

            departamento.AdicionarSetor(CentroCirurgico);

            OrcamentoHospitalar orcamento = new OrcamentoHospitalar(departamento, 2014);
            Assert.IsTrue(orcamento.Servicos.Count == 1);
        }
        public void CriarOrcamentoHospitalarComUmSetorComUmaContaDeveTerIncrementosIgualADoze()
        {
            Departamento departamento = new Hospital("Barra Dor");
            var CentroCirurgico = new SetorHospitalar("Cirurgia");
            var SubCentroCirurgico = new SubSetorHospital("Centro Cirúrgico");
            ContaHospital Cirurgia = new ContaHospital("Cirurgia", TipoValorContaEnum.Quantidade);

            CentroCirurgico.AdicionarSetor(SubCentroCirurgico);
            CentroCirurgico.AdicionarConta(Cirurgia);

            departamento.AdicionarSetor(CentroCirurgico);

            OrcamentoHospitalar orcamento = new OrcamentoHospitalar(departamento, 2014);

            Assert.IsTrue(orcamento.FatoresReceita.FirstOrDefault().Incrementos.Count == 12);
        }
        public void CalcularReceitaLiquidaOrcamentoHospitalarEmFevereiroComUmSetorComDuasContasEContaDeQuantidadeEUmaDePorcentagemEvalorDaContaEmJaneiroIgualAUmEporcentagemIgualANoventaEUnitarioIgualACemEValorComplexidadeIgualA10PorCentoNegativaValorReceitaLiuidaDeveSerIgualDoisMilSeticentosEnoventa()
        {
            Departamento departamento = new Hospital("Barra Dor");
            var Uti = new SetorHospitalar("UTI");
            var SubUtiAdulto = new SubSetorHospital("UTIAdulto");
            ContaHospital leito = new ContaHospital("Leito", TipoValorContaEnum.Quantidade);
            ContaHospital ocupacao = new ContaHospital("Ocupação", TipoValorContaEnum.Porcentagem);
            leito.MultiPlicaPorMes = true;

            Uti.AdicionarSetor(SubUtiAdulto);
            Uti.AdicionarConta(leito);
            Uti.AdicionarConta(ocupacao);

            departamento.AdicionarSetor(Uti);

            OrcamentoHospitalar orcamento = new OrcamentoHospitalar(departamento, 2014);

            var leitoProducao = orcamento.Servicos.FirstOrDefault().Valores.Where(v => v.Mes == MesEnum.Fevereiro).FirstOrDefault();

            var ocupacaoProducao = orcamento.Servicos[1].Valores.Where(v => v.Mes == MesEnum.Fevereiro).FirstOrDefault();

            leitoProducao.Valor = 1;
            ocupacaoProducao.Valor = 100;

            var incremento = orcamento.FatoresReceita.FirstOrDefault().Incrementos.Where(i => i.Mes == MesEnum.Janeiro).FirstOrDefault();
            incremento.Complexidade = 10;
            incremento.Negativo = true;

            var fevereiro = orcamento.FatoresReceita.FirstOrDefault().Incrementos.Where(i => i.Mes == MesEnum.Fevereiro).FirstOrDefault();
            orcamento.CalcularReceitaLiquida(Tickets1(100, orcamento),null);

            Assert.IsTrue(fevereiro.ReceitaLiquida == 2520);
        }
        public void CalcularReceitaLiquidaOrcamentoHospitalarCOmUmSetorComUmaContaEContaDeQuantidadeEvalorDaContaEmJaneiroIgualAUmEUnitarioIgualACemEValorComplexidadeIgualA10PorCentoValorReceitaLiquidaDeveSerIgualACentoEDez()
        {
            Departamento departamento = new Hospital("Barra Dor");
            var CentroCirurgico = new SetorHospitalar("Cirurgia");
            var SubCentroCirurgico = new SubSetorHospital("Centro Cirúrgico");
            ContaHospital Cirurgia = new ContaHospital("Cirurgia", TipoValorContaEnum.Quantidade);

            CentroCirurgico.AdicionarSetor(SubCentroCirurgico);
            CentroCirurgico.AdicionarConta(Cirurgia);

            departamento.AdicionarSetor(CentroCirurgico);

            OrcamentoHospitalar orcamento = new OrcamentoHospitalar(departamento, 2014);

            var producaoHospitalar = orcamento.Servicos.FirstOrDefault().Valores.Where(v => v.Mes == MesEnum.Janeiro).FirstOrDefault();

            producaoHospitalar.Valor = 1;

            var incremento = orcamento.FatoresReceita.FirstOrDefault().Incrementos.Where(i => i.Mes == MesEnum.Janeiro).FirstOrDefault();
            incremento.Ticket = 100;
            incremento.Complexidade = 10;

            orcamento.CalcularReceitaLiquida(Tickets(100, orcamento),null);

            Assert.IsTrue(incremento.ReceitaLiquida == 110);
        }
        public void Inicializar()
        {
            //string cnn = @"Provider=CRU.Jet.OLEDB.4.0; Data Source=C:\\preco.xls;Extended Properties='Excel 8.0;HDR=NO;'";
            //string cnn = @"Provider=Microsoft.Jet.OLEDB.4.0; Data Source=C:\\preco.xls;Extended Properties='Excel 8.0;HDR=NO;'";
            string _conectionstring;
            _conectionstring = @"Provider=Microsoft.Jet.OLEDB.4.0;";
            _conectionstring += String.Format("Data Source={0};", "D:\\Hospital2.xls");
            //_conectionstring += "Data Source=" + Server.mappath("~/adm/xls/preço.xls") + ";";
            _conectionstring += "Extended Properties='Excel 8.0;HDR=NO;'";

            OleDbConnection cn = new OleDbConnection(_conectionstring);
            OleDbCommand cmd = new OleDbCommand("Select * from [HOSPITAL x CENTRO CUSTO MOD$]", cn);

            OleDbDataAdapter da = new OleDbDataAdapter(cmd);
            System.Data.DataTable dt = new System.Data.DataTable();
            da.Fill(dt);

            int i = 0;

            List<Hospital> registrosDeIntegracao = new List<Hospital>();

            string ultimoNomeDeHospital = string.Empty;

            Hospitais hospitais = new Hospitais();

            foreach (DataRow row in dt.Rows)
            {
                if (i == 0)
                {
                    i++;
                    continue;
                }

                Hospital hospital = null;

                if (string.IsNullOrEmpty(ultimoNomeDeHospital) || ultimoNomeDeHospital != (string)row[0])
                {
                    hospital = new Hospital();
                    hospital.Nome = (string)row[0];
                }
                else
                    hospital = hospitais.ObterPor((string)row[0]);

                CentroDeCusto centroDeCusto = hospital.ObterCentroDeCustoPor(codigoDoCentroCusto: (string)row[1]);

                if (centroDeCusto == null)
                {
                    CentrosDeCusto centrosDeCusto = new CentrosDeCusto();
                    centroDeCusto = centrosDeCusto.ObterPor(codigo: (string)row[1]);

                    if (centroDeCusto == null)
                    {
                        centroDeCusto = new CentroDeCusto(nome: (string)row[2]);

                        centroDeCusto.CodigoDoCentroDeCusto = (string)row[1];

                        Conta conta = centroDeCusto.ObterContaPor((string)row[4]);

                        if (conta == null)
                        {
                            conta = CriarContaInexistente(row, centroDeCusto, conta);
                        }

                        hospital.Adicionar(centroDeCusto);
                        hospitais.Adicionar(hospital);
                    }
                    else
                    {
                        CriarContaComCentroDeCustoEncontrado(hospitais, row, hospital, centroDeCusto);
                    }
                }
                else
                {
                    CriarContaComCentroDeCustoEncontrado(hospitais, row, hospital, centroDeCusto);
                }

                ultimoNomeDeHospital = hospital.Nome;
            }

            //var hospitalBarraDor = registrosDeIntegracao.Where(x => x.NomeHospital == "BARRA D'OR");

            cn.Close();
            cn.Dispose();
            cmd.Dispose();
        }
        public void CalcularReceitaBrutaOrcamentoHospitalarReceitaBrutaDeveSerIgualATrintaEUmMil()
        {
            Departamento departamento = new Hospital("Barra Dor");
            var Uti = new SetorHospitalar("UTI");
            var SubUtiAdulto = new SubSetorHospital("UTIAdulto");
            ContaHospital leito = new ContaHospital("Leito", TipoValorContaEnum.Quantidade);
            ContaHospital ocupacao = new ContaHospital("Ocupação", TipoValorContaEnum.Porcentagem);
            leito.MultiPlicaPorMes = true;

            Uti.AdicionarSetor(SubUtiAdulto);
            Uti.AdicionarConta(leito);
            Uti.AdicionarConta(ocupacao);

            departamento.AdicionarSetor(Uti);

            OrcamentoHospitalar orcamento = new OrcamentoHospitalar(departamento, 2014);

            var leitoProducao = orcamento.Servicos.FirstOrDefault().Valores.Where(v => v.Mes == MesEnum.Janeiro).FirstOrDefault();

            var ocupacaoProducao = orcamento.Servicos[1].Valores.Where(v => v.Mes == MesEnum.Janeiro).FirstOrDefault();

            leitoProducao.Valor = 10;
            ocupacaoProducao.Valor = 100;

            var incremento = orcamento.FatoresReceita.FirstOrDefault().Incrementos.Where(i => i.Mes == MesEnum.Janeiro).FirstOrDefault();
            incremento.Ticket = 100;

            orcamento.CalcularReceitaBruta(Tickets(100, orcamento));

            Assert.IsTrue(incremento.ReceitaBruta == 31000);
        }
        protected void btnSalvar_Click(object sender, EventArgs e)
        {
            try
            {

                var antigaListaDeCentrosDeCusto = Controller.BuscarTodosOsCentrosDeCustoDeUmDepartamento(int.Parse(Session["DepartamentoLogadoId"].ToString()));
                Hospital hospital;

                if (FuncaoDaPagina == "a")
                {
                    hospital = Controller.BuscarHospitalPor(int.Parse(ddlHospitais.SelectedValue));
                    hospital.Nome = txtNome.Text;
                }
                else
                {
                    hospital = new Hospital();
                    hospital.Nome = txtNome.Text;
                }

                foreach (RepeaterItem item in rptCentrosDeCusto.Items)
                {
                    if (item.ItemType == ListItemType.Item || item.ItemType == ListItemType.AlternatingItem)
                    {
                        if (((CheckBox)item.FindControl("chkSelecionado")).Checked)
                        {

                            int centroDeCustoId = int.Parse(((HiddenField)item.FindControl("hdnIdSetor")).Value);

                            if (!hospital.CentrosDeCusto.Any(c => c.Id == centroDeCustoId))
                                hospital.Adicionar(controller.ObterCentroDeCustoPor(centroDeCustoId: centroDeCustoId));
                        }
                        else
                        {
                            int centroDeCustoId = int.Parse(((HiddenField)item.FindControl("hdnIdSetor")).Value);
                            if (hospital.CentrosDeCusto.Any(c => c.Id == centroDeCustoId))
                            {
                                if (hospital.Id > 0)
                                {
                                    var nome = ((HiddenField)item.FindControl("hdnNomeSetor")).Value;
                                    Orcamentos orcamentos = new Orcamentos();

                                    var orcamentosDeViagem = orcamentos.TodosOrcamentosDeViagemPor(hospital.CentrosDeCusto.Where(c => c.Id == centroDeCustoId).FirstOrDefault(), hospital);
                                    var orcamentosOperacionais = orcamentos.TodosOrcamentosOperacionaisPor(hospital.CentrosDeCusto.Where(c => c.Id == centroDeCustoId).FirstOrDefault(), hospital);
                                    var funcionarios = hospital.CentrosDeCusto.Where(c => c.Id == centroDeCustoId).FirstOrDefault().Funcionarios.Where(d => d.Departamento == hospital);

                                    if (orcamentosDeViagem != null && orcamentosDeViagem.Count > 0)
                                        throw new Exception("Não é possivel Retirar o Centro de Custo:" + nome + " pois ele está atrelado a pelomenos um Orcamento de viagem.");

                                    if (orcamentosOperacionais != null && orcamentosOperacionais.Count > 0)
                                        throw new Exception("Não é possivel Retirar o Centro de Custo:" + nome + " pois ele está atrelado a pelomenos um Orcamento de despesa operacional.");

                                    if (funcionarios != null && funcionarios.Count() > 0)
                                        throw new Exception("Não é possivel Retirar o Centro de Custo:" + nome + " pois ele está atrelado a pelomenos um funcionário com este Departamento.");

                                }
                                hospital.CentrosDeCusto.Remove(hospital.CentrosDeCusto.Where(c => c.Id == centroDeCustoId).FirstOrDefault());
                            }
                        }
                    }
                }

                Controller.SalvarDepartamento(hospital);
                Notificacao = "Hospital salvo com sucesso";

            }
            catch (Exception ex)
            {

                Notificacao = ex.Message;
            }

            EnviarMensagem();
            LimparCampos();
            PopularRepeaterDeCentrosDeCusto();
        }
        public void CriarOrcamentoComSucessoDeveTerOrcamentoDiferenteDeNulo()
        {
            ServicoCriarOrcamentoHospitalar servico = new ServicoCriarOrcamentoHospitalar();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            servico.Orcamentos = orcamentos;

            Departamento departamento = new Hospital("Barra dor");
            var orcamento = servico.CriarOrcamentoHospitalar(new List<Orcamento.Domain.Orcamento>(), departamento, 2014);

            Assert.IsNotNull(orcamento);
        }
 public virtual void Adicionar(Hospital hospital)
 {
     this.Salvar(hospital);
 }
        public void DeletarOrcamentoComDoisOrcamentosNaListaPrimeiroItemDaListaDeveTerNomeDeVersaoUm()
        {
            ServicoCriarOrcamentoHospitalar servico = new ServicoCriarOrcamentoHospitalar();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            orcamentos.Expect(o => o.Deletar(null)).IgnoreArguments();
            servico.Orcamentos = orcamentos;
            Departamento departamento = new Hospital("Barra dor");

            var orcamento = new OrcamentoHospitalar(departamento, 2014);

            var orcamentosLista = new List<Orcamento.Domain.Orcamento>();
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(orcamento);
            servico.DeletarOrcamento(orcamento, orcamentosLista, departamento);

            Assert.IsTrue(orcamentosLista.FirstOrDefault().NomeOrcamento == "Versão1");
        }
        public void DeletarOrcamentoComDoisOrcamentosNaListaDeveRetornarApenasCountUm()
        {
            ServicoCriarOrcamentoHospitalar servico = new ServicoCriarOrcamentoHospitalar();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            orcamentos.Expect(o => o.Deletar(null)).IgnoreArguments();
            servico.Orcamentos = orcamentos;
            Departamento departamento = new Hospital("Barra dor");

            var orcamento = new OrcamentoHospitalar(departamento, 2014);

            var orcamentosLista = new List<Orcamento.Domain.Orcamento>();
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(orcamento);
            servico.DeletarOrcamento(orcamento, orcamentosLista, departamento);

            Assert.IsTrue(orcamentosLista.Count == 1);
        }
        public void DeletarOrcamentoComDezOrcamentosNaListaDeveRetornarNomesDosORcamentosComSequenciaCerta()
        {
            ServicoCriarOrcamentoHospitalar servico = new ServicoCriarOrcamentoHospitalar();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            orcamentos.Expect(o => o.Deletar(null)).IgnoreArguments();
            servico.Orcamentos = orcamentos;
            Departamento departamento = new Hospital("Barra dor");
            var orcamento = new OrcamentoHospitalar(departamento, 2014);

            var orcamentosLista = new List<Orcamento.Domain.Orcamento>();
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(new OrcamentoHospitalar(departamento, 2014));
            orcamentosLista.Add(orcamento);
            servico.DeletarOrcamento(orcamento, orcamentosLista, departamento);
            for (int i = 0; i < orcamentosLista.Count; i++)
            {
                Assert.AreEqual(orcamentosLista[i].NomeOrcamento, "Versão" + (i + 1).ToString());
            }
        }
        public void CriarOrcamentoComSucessoDeveTerOrcamentoNomeOrcamentoDeveSerVersaoUm()
        {
            ServicoCriarOrcamentoHospitalar servico = new ServicoCriarOrcamentoHospitalar();
            IOrcamentos orcamentos = MockRepository.GenerateMock<IOrcamentos>();
            orcamentos.Expect(o => o.Salvar(null)).IgnoreArguments();
            servico.Orcamentos = orcamentos;

            Departamento departamento = new Hospital("Barra dor");
            var orcamento = servico.CriarOrcamentoHospitalar(new List<Orcamento.Domain.Orcamento>(), departamento, 2014);

            Assert.AreEqual(orcamento.NomeOrcamento, "Versão1");
        }