private IEnumerable <EntregaFixaProcessada> GeraTodasRecorrenciasDeUmaRegra(IEnumerable <Competencia> competencias = null, ParametrosDeRegraDeRemuneracao regraFixa = null)
{
PeriodoSimples periodo = competencias.ObtemPeriodoQueCompreendeTodasAsCompetencias();
DateTime inicio = periodo.Inicio;
DateTime fim = periodo.Fim;
dynamic idMoeda = regraFixa.ParametrosExtras.Dinheiro["Moeda"]["Id"];
decimal valor = decimal.Parse(regraFixa.ParametrosExtras.Dinheiro["Valor"].ToString());
Moeda moeda = Moeda.Obtem(idMoeda.ToString());
Dinheiro valorRegra = new Dinheiro(valor, moeda);
JsonSerializerSettings settingsSerializer = new JsonSerializerSettings()
{
ContractResolver = new JsonContractResolverDeModelosBase()
};
//Dinheiro valorRegra = JsonConvert.DeserializeObject<Dinheiro>(regraFixa.ParametrosExtras.Dinheiro.ToString(), settingsSerializer);
Recorrencia <DateTime> rec = JsonConvert.DeserializeObject <Recorrencia <DateTime> >(regraFixa.ParametrosExtras.Recorrencia.ToString(), settingsSerializer);
rec.Atual = regraFixa.Vigencia.Inicio;
DateTime dataReferencia = rec.Atual;
Dictionary <int, DateTime> datasDoPeriodo = new Dictionary <int, DateTime>();
Recorrencia <DateTime> atual = rec;
while (dataReferencia <= fim)
{
datasDoPeriodo.Add(atual.Serie, dataReferencia);
atual = atual.ProximoNaRecorrencia;
dataReferencia = atual.Atual;
}
atual = rec.AnteriorNaRecorrencia;
dataReferencia = atual.Atual;
List <EntregaFixaProcessada> entregas = new List <EntregaFixaProcessada>();
foreach (KeyValuePair <int, DateTime> data in datasDoPeriodo)
{
foreach (Competencia comp in competencias)
{
if (comp.Contem(data.Value))
{
EntregaFixaProcessada ent = new EntregaFixaProcessada(data.Value, comp);
ent.Serie = data.Key;
ent.IdRegra = regraFixa.Id;
entregas.Add(ent);
break;
}
}
}
return(entregas);
}
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 <ITabelaDePreco <int> > > ObtemTabelasDePrecoAsync(IEnumerable <int> idsTabelas, TipoDeTabelaDePreco tipo, PeriodoSimples periodo = null)
{
PeriodoSimples periodoRequisicao = periodo;
string apiPath = new Uri(new Uri(_endpoint), Constantes.URL_TABELA_DE_PRECO).AbsoluteUri;
RequisicaoSemConteudo <IEnumerable <ITabelaDePreco <int> > > requisicao = new RequisicaoSemConteudo <IEnumerable <ITabelaDePreco <int> > >(apiPath, _context);
if (periodoRequisicao != null)
{
requisicao.Parameters.Add(new ParametrosDaRequisicao("inicio", periodoRequisicao.Inicio.ToString("yyyy-MM-ddTHH:mm:ss")));
requisicao.Parameters.Add(new ParametrosDaRequisicao("fim", periodoRequisicao.Fim.ToString("yyyy-MM-ddTHH:mm:ss")));
}
if (tipo != null)
{
requisicao.Parameters.Add(new ParametrosDaRequisicao("Tipo", tipo.Id.ToString()));
}
if (idsTabelas?.Count() > 0)
{
requisicao.Parameters.Add(new ParametrosDaRequisicao("ids", String.Join(",", idsTabelas)));
}
System.Threading.CancellationToken cancellationToken = new System.Threading.CancellationToken();
string tabelasSerializadas = await requisicao.ObtemAsync(cancellationToken);
IEnumerable <ITabelaDePreco <int> > tabelas = DeserializarTabelas(tabelasSerializadas);
return(tabelas);
}
private async Task VerificaSeTipoLimiteJaExiste(ParametrosDeLimites limite)
{
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
ParametrosDeLimitesBD limiteBD = new ParametrosDeLimitesBD(limite);
//TODO: Talvez tenha que mudar maneira de pegar idsDosContextosDeAplicacao quando tiver mais de um contexto.
PeriodoSimples periodoLimite = new PeriodoSimples(limite.DataInicio, limite.DataFim.Value.Date.AddDays(1));
IEnumerable <int> idsVinculos = await context.VinculosLimites.Where(x => x.IdVinculo == limite.IdsDosContextosDeAplicacao.First()).Select(l => l.IdLimite).ToListAsync();
IEnumerable <ParametrosDeLimitesBD> limiteEncontrado = await context.Limites.Where(
l => l.TipoDeLimite == limiteBD.TipoDeLimite &&
l.Deleted == false &&
new PeriodoSimples(l.DataInicio, l.DataFim.Value.AddDays(1)).Intersecta(periodoLimite) &&
idsVinculos.Contains(l.Id) &&
l.Id != limite.Id).ToListAsync();
if (limiteEncontrado.Count() > 0)
{
throw new UserException("Não foi possível inserir o limite. Esta regra já possui um " + limite.Tipo.Name + " nesta vigência.");
}
}
}
public ContratoDeRemuneracao(PeriodoSimples vigencia)
{
Vigencia = vigencia;
if (Vigencia == null)
{
Vigencia = new PeriodoSimples();
}
}
public RegraDeRemuneracaoBD(TipoDeRegraBD tipo, IRegraDeRemuneracao regra) : this()
{
Vigencia = new PeriodoSimples(regra.Vigencia.Inicio.Date, regra.Vigencia.Fim.Date);
Id = regra.Id;
IdContrato = regra.Parametros.IdContrato;
Nome = regra.NomePrincipal;
this.tipo = tipo.Id;
}
public ContratoDeRemuneracao(int id, string nome, PeriodoSimples vigencia, IFavorecimento favorecimentoDoContrato, IEnumerable <IRegraDeRemuneracao> regras) : this(vigencia)
{
_regras = regras;
_favorecimento = favorecimentoDoContrato;
Id = id;
NomePrincipal = nome;
}
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));
}
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 DateTime PegaDataAleatoria(PeriodoSimples periodo)
{
TimeSpan tamanhoPeriodo = periodo.Fim.Subtract(periodo.Inicio);
int diasASubtrair = new Random().Next(tamanhoPeriodo.Days);
TimeSpan pontoDoPeriodo = tamanhoPeriodo.Subtract(new TimeSpan(diasASubtrair, 0, 0, 0));
return(periodo.Inicio.Add(pontoDoPeriodo));
}
public RegraDeRemuneracaoBD(TipoDeRegraBD tipo, ParametrosDeRegraDeRemuneracao parametros) : this()
{
Vigencia = new PeriodoSimples(parametros.Vigencia.Inicio.Date, parametros.Vigencia.Fim.Date);
Id = parametros.Id;
IdContrato = parametros.IdContrato;
Nome = parametros.NomePrincipal;
this.tipo = tipo.Id;
this.Percentual = parametros.PercentualARemunerar;
this.PercentualDesconto = parametros.PercentualDesconto;
}
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 <IEnumerable <IEntrega> > ListaVigentesNoPeriodoPorTipo(PeriodoSimples periodo, TipoDeProcedimento[] tipos)
{
DateTime inicio = periodo.Inicio;
DateTime fim = periodo.Fim;
EntregaDeHorasRecebidasBD[] entregasBD = await ObtemEntregasDoPeriodoPorTipo(inicio, fim, tipos);
IEnumerable <IEntrega> entregas = entregasBD.Select(ent => ent.ConverteParaEntrega()).ToArray();
return(entregas);
}
public void Deve_Retornar_Vazio_Ao_Fazer_Interseccao_Entre_Dois_Periodos_Distantes()
{
//Arrange
PeriodoSimples periodoA = new PeriodoSimples(new DateTime(2017, 01, 01), new DateTime(2017, 02, 01));
PeriodoSimples periodoB = new PeriodoSimples(new DateTime(2017, 03, 01), new DateTime(2017, 04, 01));
//Act
PeriodoSimples interseccao = periodoA.Interseccionar(periodoB);
//Assert
Assert.AreEqual(PeriodoSimples.Vazio, interseccao);
}
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 ContratoDeRemuneracaoBD(TipoDeContratoDeRemuneracaoBancoDeDados tipo, PeriodoSimples periodo = null)
{
TipoId = tipo.Id;
if (periodo == null)
{
Vigencia = new PeriodoSimples();
}
else
{
Vigencia = new PeriodoSimples(periodo.Inicio.Date, periodo.Fim.Date);
}
}
private void ConfigurarCompetencias()
{
_periodo_inicial_das_competencias = new PeriodoSimples(DateTime.Now, DateTime.Now.AddMonths(1));
_competencia_inicial = new CompetenciaMensal(_periodo_inicial_das_competencias.Inicio);
_segunda_competencia = _competencia_inicial.ProximaCompetencia;
_ultima_competencia = _segunda_competencia.ProximaCompetencia;
_competencias_todas = new Competencia[] { _competencia_inicial, _segunda_competencia, _ultima_competencia };
_competencias_sem_a_ultima = new Competencia[] { _competencia_inicial, _segunda_competencia };
_competencias_a_ultima = new Competencia[] { _ultima_competencia };
_competencias_a_segunda = new Competencia[] { _segunda_competencia };
_competencias_a_primeira = new Competencia[] { _competencia_inicial };
}
public async Task <IEnumerable <IEntrega> > ListaVigentesNaCompetenciaPorTipo(IEnumerable <Competencia> competencias, TipoDeProcedimento[] tipos)
{
PeriodoSimples periodo = competencias.ObtemPeriodoQueCompreendeTodasAsCompetencias();
DateTime inicio = periodo.Inicio;
DateTime fim = periodo.Fim;
EntregaDeHorasRecebidasBD[] entregasBD = await ObtemEntregasDoPeriodoPorTipo(inicio, fim, tipos);
IEnumerable <IEntrega> entregas = entregasBD.Select(ent => ent.ConverteParaEntrega()).ToArray();
return(entregas);
}
public ContratoDeRemuneracaoBD(int id, List <RegraDeRemuneracaoBD> regras, PeriodoSimples periodo = null)
{
Id = id;
Regras = regras;
if (periodo == null)
{
Vigencia = new PeriodoSimples();
}
else
{
Vigencia = new PeriodoSimples(periodo.Inicio.Date, periodo.Fim.Date);
}
}
private Mock <IRepositorioDeContratoDeRemuneracao> ConfigurarRepositorioContratos(IEnumerable <IContratoDeRemuneracao> contratos)
{
Mock <IRepositorioDeContratoDeRemuneracao> mock = new Mock <IRepositorioDeContratoDeRemuneracao>();
DateTime inicio = new DateTime(2018, 01, 01);
DateTime fim = new DateTime(2018, 02, 01);
PeriodoSimples intervaloJaneiro = new PeriodoSimples(inicio, fim);
mock.Setup(m => m.ListarVigentesEm(It.Is <Competencia[]>(comps => comps.Where(comp => comp.Periodo.Intersecta(intervaloJaneiro)).Count() > 0))).Returns(Task.FromResult(contratos));
mock.Setup(m => m.ObterAsync(It.IsAny <int[]>())).Returns(Task.FromResult(new[] { contratos?.First() }));
mock.Setup(m => m.ListarAsync()).Returns(Task.FromResult(contratos));
return(mock);
}
public ContratoDeRemuneracaoBD(int id, PeriodoSimples periodo = null)
{
Id = id;
Vigencia = periodo;
if (periodo == null)
{
Vigencia = new PeriodoSimples();
}
else
{
Vigencia = new PeriodoSimples(periodo.Inicio.Date, periodo.Fim.Date);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
var jobjTipo = jsonObject[nameof(IRegraDeRemuneracao.Tipo)];
var jobjVigencia = jsonObject[nameof(IRegraDeRemuneracao.Vigencia)];
string idTipo = jobjTipo.Value <string>();
PeriodoSimples vigencia = (PeriodoSimples)serializer.ContractResolver.ResolveContract(typeof(PeriodoSimples)).Converter.ReadJson(jobjVigencia.CreateReader(), typeof(PeriodoSimples), null, serializer);
ParametrosDeRegraDeRemuneracao parametrosDeRegraDeRemuneracao = new ParametrosDeRegraDeRemuneracao();
parametrosDeRegraDeRemuneracao.Tipo = TipoDeRegra.Hora;
JsonConvert.PopulateObject(jsonObject.ToString(), parametrosDeRegraDeRemuneracao);
return(parametrosDeRegraDeRemuneracao);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JsonConverter aux = new ConversorDePeriodo();
string nomePropriedadePeriodo = nameof(Competencia.Periodo).ToLower();
var jsonObject = JObject.Load(reader);
JToken jObjPeriodo = jsonObject.GetValue(nomePropriedadePeriodo, StringComparison.CurrentCultureIgnoreCase);
PeriodoSimples periodo = (PeriodoSimples)aux.ReadJson(jObjPeriodo.CreateReader(), typeof(PeriodoSimples), null, serializer);
//TODO melhorar conversao de competencia
Competencia competencia = new CompetenciaMensal(periodo.Inicio);
return(competencia);
}
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 ParametrosDeFavorecimento ConverteDe(FavorecimentoBD favorecimentoBD)
{
PeriodoSimples periodoDeFavorecimento = favorecimentoBD.Vigencia;
int[] idsCategorias = ConverteParametrosPorVersao(favorecimentoBD.ParametrosEspecificos).idsCategorias;
ParametrosDeFavorecimento parametros = new ParametrosDeFavorecimento()
{
Id = favorecimentoBD.Id,
IdsDasEntidadesFavorecidas = idsCategorias,
idsDasEntidadesDeExcecao = null,
TipoDeFavorecimento = TipoDeFavorecimento.Get(favorecimentoBD.tipo)
};
return(parametros);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
var mee = nameof(IContratoDeRemuneracao.Tipo);
var bii = nameof(IContratoDeRemuneracao.Vigencia);
var jobjTipo = jsonObject[mee];
var jobjVigencia = jsonObject[nameof(IContratoDeRemuneracao.Vigencia)];
string idTipo = jobjTipo.Value <string>();
PeriodoSimples vigencia = (PeriodoSimples)serializer.ContractResolver.ResolveContract(typeof(PeriodoSimples)).Converter.ReadJson(jobjVigencia.CreateReader(), typeof(PeriodoSimples), null, serializer);
IContratoDeRemuneracao contrato = TipoDeContrato.Get <TipoDeContrato>(idTipo).CriarContrato(vigencia);
serializer.Populate(jsonObject.CreateReader(), contrato);
return(contrato);
}
public ParametrosDeRegraDeRemuneracao(int id, string nome, int idContrato, decimal percentual, decimal desconto, TipoDeRegra tipo, dynamic parametros = null, PeriodoSimples vigencia = null)
{
PercentualARemunerar = percentual;
PercentualDesconto = desconto;
Id = id;
IdContrato = idContrato;
NomePrincipal = nome;
Vigencia = vigencia;
ParametrosExtras = parametros;
Tipo = tipo;
if (vigencia == null)
{
Vigencia = new PeriodoSimples(DateTime.MinValue, DateTime.MaxValue);
}
}
public static IServicoProfissional ConfiguraServicoProfissionais(IEnumerable <Profissional> funcionarios, PeriodoSimples periodoFavorecimento = null)
{
if (periodoFavorecimento == null)
{
periodoFavorecimento = new PeriodoSimples();
}
Mock <IServicoProfissional> mock = new Mock <IServicoProfissional>();
int[] idsProfissionais = funcionarios.Select(func => func.Id).ToArray();
mock.Setup(rep => rep.ObterProfissionaisAsync(It.IsAny <int[]>(), It.IsAny <PeriodoSimples>(), It.IsAny <bool>())).Returns(Task.FromResult(funcionarios));
mock.Setup(rep => rep.ObtemProfissionaisDasCategoriasNoPeriodo(It.IsAny <int[]>(), It.IsAny <PeriodoSimples>()))
.Returns((int[] x, PeriodoSimples p) => ObtemProfissionaisDasCategorias(funcionarios, x, p));
return(mock.Object);
}
public static IRepositorioDeFavorecimentos ConfiguraRepositorioFavorecidos(Profissional[] funcionarios, PeriodoSimples periodoFavorecimento = null)
{
if (periodoFavorecimento == null)
{
periodoFavorecimento = new PeriodoSimples();
}
Mock <IRepositorioDeFavorecimentos> mock = new Mock <IRepositorioDeFavorecimentos>();
int[] idsFuncionarios = funcionarios.Select(func => func.Id).ToArray();
Favorecido[] favorecidos = funcionarios.Select(func => ConfiguraMockFavorecido(func, periodoFavorecimento)).ToArray();
//mock.Setup(rep => rep.ObterAsync(It.Is<int[]>(ids => ids.Intersect(idsFuncionarios).Count() >= idsFuncionarios.Count()))).Returns(Task.FromResult(favorecidos));
//mock.Setup(rep => rep.ListarVigentesEm(It.Is<Periodo[]>(per => per.Where(p => p.Intersecta(periodoFavorecimento)).Count() >= 0))).Returns(Task.FromResult((IEnumerable<Favorecido>)favorecidos));
//mock.Setup(rep => rep.ListarVigentesEm(It.Is<Competencia[]>(per => per.Where(p => p.Periodo.Intersecta(periodoFavorecimento)).Count() >= 0))).Returns(Task.FromResult((IEnumerable<Favorecido>)favorecidos));
return(mock.Object);
}
public async Task <IEnumerable <IEntrega> > ListaVigentesNoPeriodoPorTipo(PeriodoSimples periodo, TipoDeProcedimento[] tipos)
{
ConcurrentQueue <Task <IEnumerable <IEntrega> > > tasksRepositorios = new ConcurrentQueue <Task <IEnumerable <IEntrega> > >();
Parallel.ForEach(_repositoriosEspecificos, rep =>
{
Task <IEnumerable <IEntrega> > currentTask = rep.Value.ListaVigentesNoPeriodoPorTipo(periodo, tipos);
if (currentTask != null)
{
tasksRepositorios.Enqueue(currentTask);
}
});
var entregasSeparadas = await Task.WhenAll(tasksRepositorios);
IEnumerable <IEntrega> entregas = entregasSeparadas.SelectMany(ent => ent);
return(entregas);
}
