Ejemplo n.º 1
0
        public override IEntregaPreProcessada CriarEntregaPreProcessada(IEntrega entrega, decimal percentualPermitido, DateTime dataDeEfetivacao, Competencia competencia = null)
        {
            var entregaDeHoras = (IEntregaDeHoras)entrega;

            //return new HoraProcessada(entregaDeHoras, percentualPermitido, dataDeEfetivacao, competencia);
            return(new HoraProcessada(entregaDeHoras, percentualPermitido, dataDeEfetivacao, competencia));
        }
Ejemplo n.º 2
0
        public override IEntregaPreProcessada CriarEntregaPreProcessada(IEntrega entrega, decimal percentualPermitido, DateTime dataDeEfetivacao, Competencia competencia = null)
        {
            var entregaDeHoras = (EntregaDeHoraRecebida)entrega;

            throw new NotImplementedException("WIP");
            //return new HoraRecebidaProcessada(entregaDeHoras, percentualPermitido, dataDeEfetivacao, competencia);
        }
        public async Task <int> InserirAsync(IEntrega entrega)
        {
            ConcurrentQueue <Task <int> > tasksRepositorios = new ConcurrentQueue <Task <int> >();

            Parallel.ForEach(_repositoriosEspecificos, rep =>
            {
                Task <int> currentTask = rep.Value.InserirAsync(entrega);
                if (currentTask != null)
                {
                    tasksRepositorios.Enqueue(currentTask);
                }
            });
            var idsEntregas = await Task.WhenAll(tasksRepositorios);

            int inserido = int.MinValue;

            if (idsEntregas != null && idsEntregas.Length > 0)
            {
                foreach (int id in idsEntregas)
                {
                    if (id > 0)
                    {
                        inserido = id;
                        break;
                    }
                }
            }

            return(inserido);
        }
        public async Task UpdateAsync(IEntrega modelo)
        {
            if (!modelo.Tipo.Id.Equals(Definicoes.ID_TIPO_DE_ENTREGA_HORA_RECEBIDA))
            {
                return;
            }

            throw new NotImplementedException();
        }
        private IEntrega SelecionaProcedimentoDaEntrega(IEntrega entrega)
        {
            if (ProcedimentosRemuneraveis(entrega.Procedimentos.ToArray()).Count() > 1)
            {
                throw new InvalidOperationException(String.Format("Erro ao processar entrega {0} de {1}. Apenas um procedimento é permitido", entrega.Tipo.ToString(), entrega.Executor));
            }

            return(entrega.SelecionaProcedimentos(_regime.ProcedimentosRemuneraveisNoRegime().ToArray()));
        }
        public async Task UpdateAsync(IEntrega entrega)
        {
            if (!entrega.Tipo.Id.Equals(Definicoes.ID_TIPO_DE_ENTREGA_FIXA))
            {
                return;
            }

            EntregaFixaBD entregaBanco = (EntregaFixaBD)TipoDeEntregaModeloBD.Fixa.ConverteDe(entrega);

            using (var context = _fabricaDeContextos.CriaContextoDe <EntregaContext>(TipoDeConexao.Entrega))
            {
                EntityEntry <EntregaFixaBD> entregaInserida = context.EntregasFixas.Update(entregaBanco);
                await context.SaveChangesAsync();
            }
        }
        public async Task UpdateAsync(IEntrega entrega)
        {
            ConcurrentQueue <Task> tasksRepositorios = new ConcurrentQueue <Task>();

            Parallel.ForEach(_repositoriosEspecificos, rep =>
            {
                Task currentTaks = rep.Value.UpdateAsync(entrega);
                if (currentTaks != null)
                {
                    tasksRepositorios.Enqueue(currentTaks);
                }
            });

            await Task.WhenAll(tasksRepositorios);
        }
        //private IGerenciadorDeRequisicoesFinanceiras _gerenciadorFinanceiro;

        //public ConversorDeEntregaDeHoraRecebida(IGerenciadorDeRequisicoesFinanceiras gerenciadorFinanceiro)
        //{
        //    _gerenciadorFinanceiro = gerenciadorFinanceiro;
        //}

        public IEntregaBD ConverteDe(IEntrega entrega)
        {
            if (!(entrega is EntregaDeHoraRecebida))
            {
                throw new ArgumentException("Necessário entrada de regras por hora recebida para este conversor");
            }

            EntregaDeHorasRecebidasBD entregaConvertida = new EntregaDeHorasRecebidasBD(TipoDeEntregaModeloBD.HoraRecebida);
            EntregaDeHoraRecebida     entragaHora       = entrega as EntregaDeHoraRecebida;

            entregaConvertida.Id = entragaHora.Id;

            entregaConvertida.DataDaEfetivacao = entragaHora.DataDaEfetivacao;

            throw new NotImplementedException();

            return(entregaConvertida);
        }
        public async Task <int> InserirAsync(IEntrega entrega)
        {
            if (entrega.Tipo.Id != Definicoes.ID_TIPO_DE_ENTREGA_HORA_RECEBIDA)
            {
                return(int.MinValue);
            }

            EntregaDeHorasRecebidasBD entregaBanco = (EntregaDeHorasRecebidasBD)TipoDeEntregaModeloBD.Hora.ConverteDe(entrega);

            using (var context = _fabricaDeContextos.CriaContextoDe <EntregaContext>(TipoDeConexao.Entrega))
            {
                EntityEntry <EntregaDeHorasRecebidasBD> entregaInserida = await context.EntregasDeHorasRecebidas.AddAsync(entregaBanco);

                await context.SaveChangesAsync();

                return(entregaInserida.Entity.Id);
            }
        }
        public IEntregaBD ConverteDe(IEntrega entrega)
        {
            //TODO: Por enquanto as regras possuem apenas id, o conversor terá que ser alterado para conter informações relevantes a entregas

            if (!(entrega is EntregaDeHora))
            {
                throw new ArgumentException("Necessário entrada de regras por hora para este conversor");
            }

            EntregaDeHorasBD entregaConvertida = new EntregaDeHorasBD(TipoDeEntregaModeloBD.Hora);
            EntregaDeHora    entragaHora       = entrega as EntregaDeHora;

            entregaConvertida.Id = entragaHora.Id;

            entregaConvertida.DataDaEfetivacao = entragaHora.DataDaEfetivacao;

            throw new NotImplementedException();

            return(entregaConvertida);
        }
        public IEntregaBD ConverteDe(IEntrega entrega)
        {
            if (!(entrega is IEntregaFixa))
            {
                throw new ArgumentException("Necessário entrada de entregas fixas para este conversor");
            }

            EntregaFixaBD entregaConvertida = new EntregaFixaBD(TipoDeEntregaModeloBD.Fixa);

            EntregaFixa entregaFixa = entrega as EntregaFixa;

            entregaConvertida.Id = entregaFixa.Id;
            entregaConvertida.DataDaEfetivacao = entregaFixa.DataDaEfetivacao;
            entregaConvertida.IdProfissional   = entregaFixa.IdProfissional;
            entregaConvertida.IdRegra          = entregaFixa.IdRegra;
            entregaConvertida.nrSerie          = entregaFixa.Serie;

            entregaConvertida.Vinculacao = entregaFixa.Vinculacao;
            return(entregaConvertida);
        }
Ejemplo n.º 12
0
 public abstract IEntregaPreProcessada CriarEntregaPreProcessada(IEntrega entrega, decimal percentualPermitido, DateTime dataDeEfetivacao, Competencia competencia = null);
Ejemplo n.º 13
0
 public override IEntregaPreProcessada CriarEntregaPreProcessada(IEntrega entrega, decimal percentualPermitido, DateTime dataDeEfetivacao, Competencia competencia = null)
 {
     return(new EntregaFixaProcessada(entrega.DataDaEfetivacao, competencia));
 }
 internal IEntrega ConverterDe(IEntrega entreg)
 {
     return(entreg);
 }
        private async Task <EntregaFixaProcessada> TransformaEntregaBancoEmFixaPreProcessada(IEntrega ent)
        {
            if (ent is IEntregaFixa)
            {
                EntregaFixa entFixa = (EntregaFixa)ent;

                string YYYY = entFixa.DataDaEfetivacao.Year.ToString();
                while (YYYY.Length < 4)
                {
                    YYYY = "0" + YYYY;
                }
                string MM = entFixa.DataDaEfetivacao.Month.ToString();
                while (MM.Length < 2)
                {
                    MM = "0" + MM;
                }
                string        competencia = YYYY + MM;
                Competencia[] comp        = await _gerenciadoFinanceiro.ConverteStringEmCompetenciasAsync(new string[] { competencia });

                EntregaFixaProcessada converted = new EntregaFixaProcessada(entFixa.DataDaEfetivacao, comp[0], entFixa.Executor);

                converted.Id           = entFixa.Id;
                converted.IdRegra      = entFixa.IdRegra;
                converted.SalvaNoBanco = entFixa.SalvaNoBanco;
                converted.Vinculacao   = entFixa.Vinculacao;
                converted.Serie        = entFixa.Serie;

                return(converted);
            }
            throw new InvalidOperationException("Tentativa de converter entrega nao fixa em entrega fixa");
        }
 private bool LimitaAAcoesEfetivadas(IEntrega entrega)
 {
     return(true);
     //return entrega.Procedimentos.SelectMany(proc => proc.AcoesFeitasNoProcedimento).Where(acao => acao.Tipo == Constantes.ACAO_DE_EFETIVACAO).Count() > 0;
 }
Ejemplo n.º 17
0
        public override IEntregaPreProcessada CriarEntregaPreProcessada(IEntrega entrega, decimal percentualPermitido, DateTime dataDeEfetivacao, Competencia competencia)
        {
            var entregaDeEvento = (EntregaDeEventoDeAgenda)entrega;

            return(new EventoDeAgendaPreProcessado(entregaDeEvento, percentualPermitido, dataDeEfetivacao, competencia));
        }
Ejemplo n.º 18
0
 public override IEntregaPreProcessada CriarEntregaPreProcessada(IEntrega entrega, decimal percentualPermitido, DateTime dataDeEfetivacao, Competencia competencia)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 19
0
        protected virtual IEnumerable <IEntregaPreProcessada> ConverteEntregaEmRemuneravel(IEntrega entrega, Competencia competenciaDaEntrega = null)
        {
            IEnumerable <IEntregaPreProcessada> remuneraveis = entrega.Procedimentos.Select((proc) =>
            {
                decimal percentualPermitido       = 100.0M;
                IEnumerable <decimal> percentuais = ObtemModificacoesDasAcoesFeitasNoProcedimento(proc);

                percentualPermitido = proc.PercentualPermitido * (percentuais.Sum(p => p / 100.0M));

                IEntregaPreProcessada remuneravel = entrega.Tipo.CriarEntregaPreProcessada(entrega, percentualPermitido, proc.DataDaOcorrencia);

                remuneravel.Vinculacao.Adicionar(new Vinculo(Constantes.HISTORICO_TIPO_PROCEDIMENTO, proc.Id, proc.Tipo.ToString()));

                return(remuneravel);
            });

            var remun = remuneraveis.ToList();

            return(remuneraveis);
        }