public void Deve_Remunerar_Linearmente_Proporcional_Ao_Percentual_Configurado_Para_a_Regra()
{
//Arrange
Random rnd = new Random();
decimal multiplicador = rnd.Next(0, 100) / 100.0M;
var valorHora = new Dinheiro(valor: 100M, moeda: Moeda.Real);
Mock <ITabelaDePreco <int> > tabelaMock = GeraTabelaMock(valorHora);
Profissional favorecido = LOMock.GeraProfissionalMock(id: 1, categoria: new Categoria(), nome: "LeMock");
IFavorecimento favorecimento = LOMock.GeraFavorecimentoMock(new[] { favorecido });
ParametrosDeRegraDeRemuneracao parametrosRegra1 = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 100);
ParametrosDeRegraDeRemuneracao parametrosRegra2 = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 100 * multiplicador);
IRegraDeRemuneracao regra1 = LOMock.ConstroiRegraPorHora(parametrosRegra1, favorecimento, tabelaMock.Object);
IRegraDeRemuneracao regra2 = LOMock.ConstroiRegraPorHora(parametrosRegra2, favorecimento, tabelaMock.Object);
Mock <IHoraPreProcessada> entregaMock = ConfiguraMockEntregaRemuneravel(5, favorecido);
//Act
IEnumerable <IRemuneracao> remuneracoesA = regra1.CalculaRemuneracoes(new IEntregaPreProcessada[] { entregaMock.Object });
IEnumerable <IRemuneracao> remuneracoesB = regra2.CalculaRemuneracoes(new IEntregaPreProcessada[] { entregaMock.Object });
IEnumerator <IRemuneracao> enumeratorA = remuneracoesA.GetEnumerator();
IRemuneracao RemuneracaoA = remuneracoesA.First();
IEnumerator <IRemuneracao> enumeratorB = remuneracoesB.GetEnumerator();
IRemuneracao RemuneracaoB = remuneracoesB.First();
//Assert
Assert.AreEqual(multiplicador * RemuneracaoA.ValorAjustado.Valor, RemuneracaoB.ValorAjustado.Valor);
}
public async Task <IActionResult> InserirRegra([FromBody] JObject regraJson)
{
//context = await ConfiguraGerenciador(context);
try
{
int id;
var json = regraJson.ToString();
ParametrosDeRegraDeRemuneracao regra = ConverteJsonParaRegra(json);
id = await _gerenciadorDeRequisicoes.SalvaRegraAsync(regra);
EncapsuladorDeResposta <int> encapsuledResponse = new EncapsuladorDeResposta <int>(id);
encapsuledResponse.Success = true;
return(Ok(encapsuledResponse));
}
catch (UserException ex)
{
EncapsuladorDeResposta <int> encapsuledResponse = new EncapsuladorDeResposta <int>(0);
encapsuledResponse.Success = false;
encapsuledResponse.ExceptionMessage = ex.Message;
return(Ok(encapsuledResponse));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task Deve_Adicionar_Nova_Entrada_De_Regra_No_Banco_Desenv()
{
//Arrange
IRepositorioDeRegras repo = TesteInfraService.ServiceProvider.GetService <IRepositorioDeRegras>();
Mock <IFavorecimento> favorecimentoMock = new Mock <IFavorecimento>();
favorecimentoMock.SetupAllProperties();
Profissional funcionario1 = new Profissional(1, null, "Fernando");
Profissional funcionario2 = new Profissional(2, null, "Bronze");
Profissional funcionario3 = new Profissional(3, null, "Cinco");
Profissional[] funcionarios = new Profissional[] { funcionario1, funcionario2, funcionario3 };
ParametrosDeRegraDeRemuneracao parametros = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 50, vigencia: new PeriodoSimples(new DateTime(2018, 05, 01), new DateTime(2018, 08, 24)));
RegraPorHora regraHora = null;//new RegraPorHora(parametros);
int idInserido;
//Act
idInserido = await repo.InserirAsync(regraHora);
throw new NotImplementedException();
//IRegraDeRemuneracao[] regraObtida = await repo.ObterAsync(new int[] { idInserido });
////Assert
//Assert.IsNotNull(regraObtida[0]);
//Assert.AreEqual(regraHora.Tipo, regraObtida[0].Tipo);
}
public IConstrutorDeRegraDeRemuneracao ComParametros(ParametrosDeRegraDeRemuneracao parametros)
{
var regra = new RegraFixaPorValor(parametros, _repositorioDeEntregasFixas);
_regraConstruida = regra;
ConstruirParametrosEspecificos();
return(this);
}
public static ParametrosDeRegraDeRemuneracao GeraParametrosDeRegraDeRemuneracaoPorHoraMock(decimal percentual = 100M, decimal desconto = 0M, PeriodoSimples vigencia = null)
{
var parametros = new ParametrosDeRegraDeRemuneracao(0, "", 0, percentual, desconto, TipoDeRegra.EventoDeAgenda, vigencia: vigencia);
parametros.ParametrosExtras = new ExpandoObject();
parametros.ParametrosExtras.IdTabelaDePreco = 1;
parametros.ParametrosExtras.Versao = "1";
return(parametros);
}
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 static IRegraDeRemuneracao ConstroiRegraPorHora(ParametrosDeRegraDeRemuneracao parametrosDeRegra, IFavorecimento favorecimento, ITabelaDePreco <int> tabelaDePreco)
{
Fixture fixture = new Fixture();
IServicoFaturamento servicoFaturamento = ConfigurarServicoFaturamentoMock(tabelasDePreco: new[] { tabelaDePreco });
IServicoRetaguarda servicoRetaguarda = ConfiguraRetaguardaMock(servicoFaturamento);
IRegraDeRemuneracao regra = new ConstrutorDeRegraDeRemuneracaoPorHora(servicoRetaguarda)
.ComFavorecimento(favorecimento)
.ComParametros(parametrosDeRegra)
.Construir();
return(regra);
}
public RegraDeRemuneracaoBD ConverterDe(ParametrosDeRegraDeRemuneracao parametros)
{
if (!(parametros.Tipo == TipoDeRegra.Fixa))
{
throw new ArgumentException("Este conversor converte apenas regras fixas");
}
RegraDeRemuneracaoBD regraConvertida = new RegraDeRemuneracaoBD(TipoDeRegraBD.Fixa, parametros);
regraConvertida.Parametros = JsonConvert.SerializeObject(parametros.ParametrosExtras);
return(regraConvertida);
}
public async Task UpdateAsync(ParametrosDeRegraDeRemuneracao modelo)
{
var tipoDaRegra = TipoDeRegraBD.Get(modelo.Tipo.Id);
RegraDeRemuneracaoBD regra = tipoDaRegra.ConverterDe(modelo);
await VerificaSeRegraEstaNaVigenciaDoContrato(regra);
await VerificaSeJaExisteRegraComMesmoTipoNoContrato(regra);
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
context.Update(regra);
await context.SaveChangesAsync();
}
}
public ParametrosDeRegraDeRemuneracao ConverterDe(RegraDeRemuneracaoBD regraBD)
{
dynamic parametrosExtras = null;
if (regraBD.Parametros != null)
{
JObject jobj = JsonConvert.DeserializeObject <JObject>(regraBD.Parametros);
parametrosExtras = new ExpandoObject();
parametrosExtras.Versao = jobj["Versao"];
parametrosExtras.IdTabelaDePreco = jobj["IdTabelaDePreco"];
}
ParametrosDeRegraDeRemuneracao parametros = new ParametrosDeRegraDeRemuneracao(regraBD.Id, regraBD.Nome, regraBD.IdContrato, regraBD.Percentual, regraBD.PercentualDesconto, TipoDeRegra.Hora, parametros: parametrosExtras, vigencia: regraBD.Vigencia);
return(parametros);
}
public RegraDeRemuneracaoBD ConverterDe(ParametrosDeRegraDeRemuneracao parametros)
{
if (!(parametros.Tipo == TipoDeRegra.Hora))
{
throw new ArgumentException("Este conversor converte apenas regras por hora");
}
RegraDeRemuneracaoBD regraConvertida = new RegraDeRemuneracaoBD(TipoDeRegraBD.Hora, parametros);
regraConvertida.Percentual = parametros.PercentualARemunerar;
regraConvertida.PercentualDesconto = parametros.PercentualDesconto;
regraConvertida.Parametros = JsonConvert.SerializeObject(parametros.ParametrosExtras);
return(regraConvertida);
}
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 async Task <int> InserirAsync(ParametrosDeRegraDeRemuneracao modelo)
{
var tipoDaRegra = TipoDeRegraBD.Get(modelo.Tipo.Id);
RegraDeRemuneracaoBD regra = tipoDaRegra.ConverterDe(modelo);
await VerificaSeRegraEstaNaVigenciaDoContrato(regra);
await VerificaSeJaExisteRegraComMesmoTipoNoContrato(regra);
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
EntityEntry <RegraDeRemuneracaoBD> insertedObject = await context.Regras.AddAsync(regra);
await context.SaveChangesAsync();
return(insertedObject.Entity.Id);
}
}
public async Task Deve_Vincular_Regras_A_Contrato()
{
//Arrange
IRepositorioDeContratoDeRemuneracao repoContrato = TesteInfraService.ServiceProvider.GetService <IRepositorioDeContratoDeRemuneracao>();
IRepositorioDeRegras repoRegra = TesteInfraService.ServiceProvider.GetService <IRepositorioDeRegras>();
Mock <IFavorecimento> favorecimentoMock = new Mock <IFavorecimento>();
favorecimentoMock.SetupAllProperties();
Profissional funcionario1 = new Profissional(1, null, "Fernando");
Profissional funcionario2 = new Profissional(2, null, "Bronze");
Profissional funcionario3 = new Profissional(3, null, "Cinco");
Profissional[] funcionarios = new Profissional[] { funcionario1, funcionario2, funcionario3 };
ParametrosDeRegraDeRemuneracao parametros = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 50, vigencia: new PeriodoSimples(new DateTime(2018, 05, 01), new DateTime(2018, 08, 24)));
RegraPorHora regraHora1 = null;//new RegraPorHora(parametros);
parametros = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 60, vigencia: new PeriodoSimples(new DateTime(2018, 06, 01), new DateTime(2018, 08, 24)));
RegraPorHora regraHora2 = null;//new RegraPorHora(parametros);
parametros = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 70, vigencia: new PeriodoSimples(new DateTime(2018, 07, 01), new DateTime(2018, 08, 24)));
RegraPorHora regraHora3 = null;// new RegraPorHora(parametros);
ContratoDeRemuneracao contratoCriado = new ContratoDeRemuneracao(new PeriodoSimples(new DateTime(2018, 03, 01), new DateTime(2018, 04, 01)));
//Act
List <int> idsRegra = new List <int>
{
{ await repoRegra.InserirAsync(regraHora1) },
{ await repoRegra.InserirAsync(regraHora2) },
{ await repoRegra.InserirAsync(regraHora3) }
};
int idContrato = await repoContrato.InserirAsync(contratoCriado);
await repoContrato.AtualizaVinculosAsync(idContrato, idsRegra.ToArray());
IContratoDeRemuneracao[] contratoObtido = await repoContrato.ObterAsync(new int[] { idContrato });
IRegraDeRemuneracao[] regrasObtidas = (await repoRegra.ObterAsync(idsRegra.ToArray())).Select(p => p.Tipo.Construtor(null, null).ComParametros(p).ComFavorecimento(favorecimentoMock.Object).Construir()).ToArray();
IEnumerable <IRegraDeRemuneracao> regrasVinculadas = contratoObtido[0].Regras;
//Assert
Assert.AreEqual(idContrato, contratoObtido[0].Id);
Assert.IsNotNull(regrasVinculadas);
Assert.IsTrue(regrasVinculadas.Count() > 0);
}
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");
}
}
}
}
public void Deve_Remunerar_Favorecido_Conforme_Tabela()
{
//Arrange
Profissional favorecido = LOMock.GeraProfissionalMock(id: 1, categoria: new Categoria(), nome: "LeMock");
IFavorecimento favorecimento = LOMock.GeraFavorecimentoMock(new[] { favorecido });
var valorHora = new Dinheiro(valor: 100M, moeda: Moeda.Real);
Mock <ITabelaDePreco <int> > tabelaMock = GeraTabelaMock(valorHora);
ParametrosDeRegraDeRemuneracao parametrosRegra = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 100M);
IRegraDeRemuneracao regra = LOMock.ConstroiRegraPorHora(parametrosRegra, favorecimento, tabelaMock.Object);
Mock <IHoraPreProcessada> entrega = ConfiguraMockEntregaRemuneravel(5, favorecido);
//Act
IEnumerable <IRemuneracao> remuneracoes = regra.CalculaRemuneracoes((new IEntregaPreProcessada[] { entrega.Object }));
IRemuneracao Remuneracao = remuneracoes.First();
//Assert
Assert.AreEqual(favorecido.Id, Remuneracao.IdFavorecido);
Assert.AreEqual(5 * valorHora.Valor, Remuneracao.ValorAjustado.Valor);
}
public async Task <IActionResult> UpdateAsync([FromBody] JObject regraJson)
{
ParametrosDeRegraDeRemuneracao regra = ConverteJsonParaParametrosDeRegra(regraJson.ToString());
EncapsuladorDeResposta <int> encapsuledResponse = new EncapsuladorDeResposta <int>(0);
try
{
await _gerenciadorDeRequisicoes.AtualizarRegra(regra);
}
catch (UserException ex)
{
encapsuledResponse.Success = false;
encapsuledResponse.ExceptionMessage = ex.Message;
return(Ok(encapsuledResponse));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
encapsuledResponse.Success = true;
return(Ok(encapsuledResponse));
}
private IEnumerable <EntregaFixaProcessada> GeraTodasRecorrenciasDeUmaRegra(PeriodoSimples periodo, ParametrosDeRegraDeRemuneracao regraFixa)
{
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)
{
EntregaFixaProcessada ent = new EntregaFixaProcessada(data.Value);
ent.Serie = data.Key;
ent.IdRegra = regraFixa.Id;
entregas.Add(ent);
}
return(entregas);
}
public async Task <IEnumerable <EntregaDeSaldoFuncionario> > ObterEntregasDeSaldoDosFuncionariosDaRegra(ParametrosDeRegraDeRemuneracao modelo)
{
var tipoDaRegra = TipoDeRegraBD.Get(modelo.Tipo.Id);
RegraDeRemuneracaoBD regra = tipoDaRegra.ConverterDe(modelo);
ParametrosDeFavorecimento fav = new ParametrosDeFavorecimento();
using (var context = _fabricaDeContextos.CriaContextoDe <RemuneracaoContext>(TipoDeConexao.Remuneracao))
{
ContratoDeRemuneracaoBD contrato = await context.Contratos
.Include(c => c.Favorecimento)
.Where(x => x.Id == regra.IdContrato).FirstOrDefaultAsync();
if (contrato.Favorecimento == null)
{
return(new List <EntregaDeSaldoFuncionario>());
}
fav = contrato.Favorecimento.ConverterPara();
}
using (var context = _fabricaDeContextos.CriaContextoDe <EntregaContext>(TipoDeConexao.Entrega))
{
IEnumerable <EntregaDeSaldoFuncionarioBD> entregas = await context.EntregasSaldoFuncionario
//.Include(c=>c.Regra)
.Where(x => fav.IdsDasEntidadesFavorecidas.Contains(x.IdFuncionario)).ToArrayAsync();
IEnumerable <EntregaDeSaldoFuncionario> retorno = ConversorEntregaBSFuncionario.ConverteParaDominio(entregas);
return(retorno);
}
}
public async Task <bool> AtualizarEntregasDosFuncionariosDaRegra(IEnumerable <EntregaDeSaldoFuncionario> entregas, ParametrosDeRegraDeRemuneracao paramRegra, IEnumerable <ITabelaDePreco <int> > tabelasDePreco)
{
var idEntregas = entregas.Select(x => x.Id).Distinct();
var tipoDaRegra = TipoDeRegraBD.Get(paramRegra.Tipo.Id);
RegraDeRemuneracaoBD regra = tipoDaRegra.ConverterDe(paramRegra);
var idTabelaDePreco = paramRegra.ParametrosExtras.IdTabelaDePreco.Value;
ITabelaDePreco <int> tabela = tabelasDePreco.Single(x => x.Id == idTabelaDePreco);
using (var context = _fabricaDeContextos.CriaContextoDe <EntregaContext>(TipoDeConexao.Entrega))
{
foreach (var idEntrega in idEntregas)
{
EntregaDeSaldoFuncionarioBD entrega = await context.EntregasSaldoFuncionario.FindAsync(idEntrega);
Dinheiro valorHora = tabela.PrecoEm(entrega.DataFaturamento, entrega.IdCategoria, Moeda.Real);
entrega.IdRegra = regra.Id;
entrega.PercentualDeRemuneracao = (int)regra.Percentual;
entrega.Valor = (entrega.QtdMinutos / 60) * valorHora.Valor;
entrega.ValorHora = valorHora.Valor;
context.EntregasSaldoFuncionario.Update(entrega);
}
try
{
await context.SaveChangesAsync();
}
catch (Exception ex)
{
return(false);
}
return(true);
}
}
public RegraDeRemuneracaoBD ConverterDe(ParametrosDeRegraDeRemuneracao parametros)
{
return(Conversor.ConverterDe(parametros));
}
