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)); }