private bool DataEstaNoPeriodo(PeriodoSimples periodo, DateTime inicio, DateTime fim)
{
if (periodo.Contem(inicio) || periodo.Contem(fim) || (inicio < periodo.Inicio && fim >= periodo.Fim))
{
return(true);
}
return(false);
}
private async Task VerificaSeLimiteEstaNaVigenciaDaRegra(ParametrosDeLimites limite)
{
ParametrosDeRegraDeRemuneracao regraDoLimite = (await _repositorioDeRegras.ObterAsync(limite.IdsDosContextosDeAplicacao)).First();
PeriodoSimples vigenciaDaRegraDoLimite = new PeriodoSimples(regraDoLimite.Vigencia.Inicio.Date, regraDoLimite.Vigencia.Fim.Date.AddDays(1));
if (!vigenciaDaRegraDoLimite.Contem(limite.DataInicio.Value.Date) || !vigenciaDaRegraDoLimite.Contem(limite.DataFim.Value.Date))
{
throw new UserException("A vigência do Limite deve estar dentro da vigência da regra");
}
}
public async Task <IActionResult> CalculaRemuneracoes(DateTime inicio, DateTime fim, int pag = 1)
{
IEnumerable <IRemuneracao> remuneracoes;
try
{
DateTime dataFimAjustada = new DateTime(fim.Date.Ticks).AddDays(1).AddSeconds(-1);
PeriodoSimples periodoDoPagamentoDasHoras = new PeriodoSimples(inicio.Date, dataFimAjustada);
remuneracoes = await _gerenciadorDeRemuneracao.CalcularRemuneracoesNoPeriodoAsync(periodoDoPagamentoDasHoras);
//TODO reimplementar a paginação do backend (preferencialmente salvando a requisicao antes
//var remuneracoesPorFavorecido = remuneracoes.GroupBy(rem => rem.IdFavorecido).OrderBy(g => g.Key);
//const int pagesize = 10;
//IEnumerable<IRemuneracao> pagina = remuneracoesPorFavorecido.Skip(pagesize * (pag - 1)).Take(pagesize).SelectMany(gr => gr).ToArray();
//return base.Ok(pagina);
//filtro para exibir apenas remuneracoes do periodo selecionado. (O calculo gera as remuneracoes fixas recorrentes{baseado na vigencia da regra Fixa})
remuneracoes = remuneracoes.Where(x => periodoDoPagamentoDasHoras.Contem(x.DataDaEntrega)).OrderBy(x => x.IdFavorecido);
return(base.Ok(remuneracoes));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IEnumerable <IEntrega> > ListaEntregasDoBancoPorRegraNoPeriodo(IEnumerable <int> idsRegras, PeriodoSimples periodo, string idTipoDeEntrega)
{
if (!idTipoDeEntrega.Equals(Definicoes.ID_TIPO_DE_ENTREGA_FIXA) ||
idsRegras == null || idsRegras.Count() == 0 ||
periodo == null)
{
return(new List <IEntrega>());
}
IEnumerable <EntregaFixaBD> entregasDB;
using (var context = _fabricaDeContextos.CriaContextoDe <EntregaContext>(TipoDeConexao.Entrega))
{
entregasDB = await(from ent in context.EntregasFixas
where idsRegras.Contains(ent.IdRegra) &&
periodo.Contem(ent.DataDaEfetivacao)
select ent).ToArrayAsync();
}
if (entregasDB == null || entregasDB.Count() == 0)
{
return(new List <IEntrega>());
}
IEnumerable <IEntrega> entregas = entregasDB.Select(ent => ent.ConverteParaEntrega()).ToArray();
return(entregas);
}
public void Periodo_Vazio_Nao_Deve_Conter_Nenhuma_Data()
{
//Arrange
PeriodoSimples vazio = PeriodoSimples.Vazio;
DateTime data = DateTime.Now.AddDays(new Random().Next(30));
//Act & Assert
Assert.False(vazio.Contem(data));
}
public async Task VerificaSeExisteLimiteForaDaNovaVigenciaDaRegra(ParametrosDeRegraDeRemuneracao regra)
{
IEnumerable <IParametros> limitesDaRegra = await ListarLimitesPorRegra(regra.Id);
foreach (IParametros limite in limitesDaRegra)
{
if (limite is ParametrosDeLimites)
{
DateTime inicio = ((ParametrosDeLimites)limite).DataInicio.Value.Date;
DateTime fim = ((ParametrosDeLimites)limite).DataFim.Value.Date;
PeriodoSimples vigenciaDaRegra = new PeriodoSimples(regra.Vigencia.Inicio.Date, regra.Vigencia.Fim.Date.AddDays(1));
if (!vigenciaDaRegra.Contem(inicio) || !vigenciaDaRegra.Contem(fim))
{
throw new UserException("Existem limites com vigência fora da nova vigência da regra, favor alterá-los antes de alterar a regra");
}
}
}
}
private async Task VerificaSeRegraEstaNaVigenciaDoContrato(RegraDeRemuneracaoBD regra)
{
IContratoDeRemuneracao contratoDaRegra = (await _repositorioDeContratos.ObterAsync(new int[] { regra.IdContrato })).First();
PeriodoSimples vigenciaDoContrato = new PeriodoSimples(contratoDaRegra.Vigencia.Inicio.Date, contratoDaRegra.Vigencia.Fim.Date.AddDays(1));
PeriodoSimples vigenciaDaRegra = new PeriodoSimples(regra.Vigencia.Inicio.Date, regra.Vigencia.Fim.Date);
if (!vigenciaDoContrato.Contem(vigenciaDaRegra))
{
throw new UserException("A vigência da regra deve estar dentro da vigência do contrato");
}
}
public async Task VerificaSeExisteRegraForaDaNovaVigenciaDoContrato(IContratoDeRemuneracao contrato, int id)
{
IEnumerable <ParametrosDeRegraDeRemuneracao> regras = await ListaRegras(id);
PeriodoSimples vigenciaDoContrato = new PeriodoSimples(contrato.Vigencia.Inicio.Date, contrato.Vigencia.Fim.Date.AddDays(1));
foreach (ParametrosDeRegraDeRemuneracao regra in regras)
{
PeriodoSimples vigenciaDaRegra = new PeriodoSimples(regra.Vigencia.Inicio.Date, regra.Vigencia.Fim.Date);
if (!vigenciaDoContrato.Contem(vigenciaDaRegra))
{
throw new UserException("Existem regras com vigência fora da nova vigência do contrato, favor alterá-las antes de alterar o contrato");
}
}
}
public async Task <IEnumerable <IRemuneracao> > ObtemLancamentosDeFechamentoNoPeriodo(PeriodoSimples periodo)
{
IEnumerable <IRemuneracao> remuneracoesFechadas;
//string[] competenciasSerializadas = competencias.Select(comp => comp.ToString()).ToArray();
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
var remuneracoesBDs = await(from remBD in context.LancamentosDeFechamento.Include(lanc => lanc.Excedentes).ThenInclude(exc => exc.ParametrosLimites)
where remBD.DataDoCancelamentoDoFechamento == null &&
periodo.Contem(remBD.DataDaEntrega)
//competenciasSerializadas.Contains(remBD.CompetenciaSerializada)
select remBD).ToArrayAsync();
remuneracoesFechadas = remuneracoesBDs.Select(rBD => rBD.ConverteParaModelo());
}
return(remuneracoesFechadas);
}
public async Task <IEnumerable <IEmissaoDeRemuneracao> > ObtemEmissoesNoPeriodo(PeriodoSimples periodo)
{
IEnumerable <IEmissaoDeRemuneracao> emissoes;
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
IEnumerable <EmissaoDeRemuneracaoBD> emissoesBD = await(from emissBD in context.Emissoes.Include(p => p.RemuneracoesEmitidas)
where emissBD.DataDoCancelamento == null
select emissBD).ToArrayAsync();
var idEmissoesNoPeriodo = emissoesBD.SelectMany(x => x.RemuneracoesEmitidas).Where(x => periodo.Contem(x.DataDaEntrega)).Select(c => c.IdEmissao).Distinct();
emissoesBD = emissoesBD.Where(x => idEmissoesNoPeriodo.Contains(x.Id));
emissoes = emissoesBD.Select(emissBD => emissBD.ConverteParaModelo());
}
return(emissoes);
}