public static IEnumerable <object[]> CenariosComDescontoMaiorQueValorBruto()
{
List <object[]> casos = new List <object[]>();
Dinheiro zero = Dinheiro.Zero;
try
{
IFechamentoDeRemuneracao fechamentoAlvo = LOMock.ConfiguraFechamento(LOMock.ID_FECHAMENTO_MOCK, LOMock.ID_FAVORECIDO, Dinheiro.EmReais(200), Dinheiro.EmReais(200));
var caso1 = new object[] { fechamentoAlvo, zero, zero };
var caso2 = new object[] { fechamentoAlvo, Dinheiro.EmReais(100), zero };
var caso3 = new object[] { fechamentoAlvo, Dinheiro.EmReais(300), zero };
casos.Add(caso1);
casos.Add(caso2);
casos.Add(caso3);
}
catch (Exception ex)
{
throw ex;
}
//Nao permitir casos zerados
return(casos.Where(caso => (!caso[1].Equals(zero) || !caso[2].Equals(zero)) && ((IFechamentoDeRemuneracao)caso[0]).ValorBruto < (Dinheiro)caso[1]));
}
public void ConverterDolar()
{
Assert.IsTrue(Dinheiro.ConverterDolar(10) == "$10.00");
Assert.IsTrue(Dinheiro.ConverterDolar(10.2M) == "$10.20");
Assert.IsTrue(Dinheiro.ConverterDolar(564.52f) == "$564.52");
Assert.IsTrue(Dinheiro.ConverterDolar(2000.10) == "$2,000.10");
}
protected void SetUp()
{
Id = Guid.NewGuid();
Tamanho = new Tamanho(122.53M, "KG");
Fabricacao = Fabricacao.Importado;
Valor = new Dinheiro(100M);
}
public void ConverterReal()
{
Assert.IsTrue(Dinheiro.ConverterReal(10) == "R$ 10,00");
Assert.IsTrue(Dinheiro.ConverterReal(10.2M) == "R$ 10,20");
Assert.IsTrue(Dinheiro.ConverterReal(564.52f) == "R$ 564,52");
Assert.IsTrue(Dinheiro.ConverterReal(2000.10) == "R$ 2.000,10");
}
public IEnumerable <IRemuneracao> AbaterValorExcedenteDasRemuneracoes(ILimiteDeRemuneracao limiteOriginario, IEnumerable <IRemuneracao> remuneracoes, Dinheiro valorExcedente)
{
//TODO funciona apenas para real
Dinheiro valorTotal = remuneracoes.Select(rem => rem.ValorAjustado).SomaDinheiro();
ConcurrentStack <IRemuneracao> remuneracoesAbatidas = new ConcurrentStack <IRemuneracao>();
Dinheiro totalAbatido = Dinheiro.Zero;
Parallel.ForEach(remuneracoes, (rem) =>
{
decimal percentualDeAbatimento = decimal.Round(rem.ValorAjustado / valorTotal, 7);
Dinheiro valorDoAbatimento = percentualDeAbatimento * valorExcedente;
Dinheiro valorDoAbatimentoArrendondado = Dinheiro.Arredondar(valorDoAbatimento, 7);
IRemuneracao remuneracaoDivididaEmPartesAbatidas = AbaterRemuneracao(rem, valorDoAbatimentoArrendondado, limiteOriginario);
if (limiteOriginario.Tipo.Id.Equals("LIMITE_MINIMO") && remuneracaoDivididaEmPartesAbatidas.ValorAjustado > Dinheiro.Zero || limiteOriginario.Tipo.Id.Equals("LIMITE_MAXIMO"))
{
remuneracoesAbatidas.Push(remuneracaoDivididaEmPartesAbatidas);
totalAbatido += valorDoAbatimentoArrendondado;
}
});
Dinheiro diferencaDeExcedente = Dinheiro.Arredondar(valorExcedente - totalAbatido, 6);
if (diferencaDeExcedente != Dinheiro.Zero && remuneracoesAbatidas.Count() > 0)
{
CorrecaoDeArredondamentoDeExcedente(remuneracoesAbatidas.First(), diferencaDeExcedente);
}
return(remuneracoesAbatidas);
}
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 Property TesteDivisaoPorZeroRetornaListaVazia(decimal valor)
{
Dinheiro dinheiro = valor;
var divisao = dinheiro.DividirEntre(0);
return((!divisao.Any()).ToProperty());
}
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 bool dinheiroDisponivel(int totalConta)
{
if (totalConta <= Dinheiro.ObterValor())
{
return(true);
}
return(false);
}
public void GiveMoney()
{
int dinheiroEarned = MoneyCalculation();
SaveManager.player.dinheiro += dinheiroEarned;
Dinheiro.CreateGain(dinheiroEarned, moneyText.transform.position);
UpdateTextMoney();
}
public Property TesteDivisaoNaoPerdeDinheiro2(decimal valor, uint divisor)
{
Dinheiro dinheiro = valor;
var divisao = dinheiro.DividirEntre(divisor);
Func <bool> property = () => dinheiro.Equals(divisao.Aggregate((Dinheiro)0, (acc, novo) => acc + novo));
return(property.When(valor > 0 && divisor > 0));
}
private static Mock <ITabelaDePreco <int> > GeraTabelaMock(Dinheiro valorHora, int id = ID_TABELA_PRECO)
{
Mock <ITabelaDePreco <int> > tabelaMock = new Mock <ITabelaDePreco <int> >();
tabelaMock.Setup(tab => tab.PrecoEm(It.IsAny <DateTime>(), It.IsAny <int>(), It.IsAny <Moeda>())).Returns(delegate { return(valorHora); });
tabelaMock.Setup(tab => tab.Id).Returns(id);
return(tabelaMock);
}
public Arma(String nome, Dinheiro dinheiro, Dano dano, float peso, String propriedades, String categoria)
{
this.nome = nome;
this.valor = dinheiro;
this.dano = dano;
this.peso = peso;
this.propriedades = propriedades;
this.categoria = categoria;
}
public void Lanca_Excecao_Se_Desconto_For_Maior_Que_Valor_Bruto(IFechamentoDeRemuneracao fechamentoDeRemuneracao, Dinheiro desconto, Dinheiro bonus)
{
//Arrange
Initialize(fechamentoDeRemuneracao);
Dinheiro valorBruto = fechamentoDeRemuneracao.ValorBruto;
//Act && Assert
Assert.Throws(typeof(AggregateException), () => _diretor.AplicaAjustesA(fechamentoDeRemuneracao.Id, desconto, bonus).Wait());
}
public void TesteDivisaoNaoPerdeDinheiro()
{
Dinheiro dinheiro = 1.00M;
var divisao = dinheiro.DividirEntre(3);
Assert.Collection(divisao
, item => Assert.Equal(0.34M, item)
, item => Assert.Equal(0.33M, item)
, item => Assert.Equal(0.33M, item));
}
public void Deve_formatar_como_string()
{
var dinheiro = new Dinheiro("R$", 10.50m);
var dinheiroComoString = dinheiro.ToString();
var esperado = string.Format("{0} {1:n2}", dinheiro.Moeda, dinheiro.Valor);
Assert.AreEqual(esperado, dinheiroComoString);
}
public static Produto CriarProdutoInternacional(Guid id,
Tamanho tamanho,
Fabricacao fabricacao,
Dinheiro valor)
{
return(new ProdutoInternacional(id,
tamanho,
fabricacao,
valor));
}
public void AtualizarValores(Guid id,
Tamanho tamanho,
Fabricacao fabricacao,
Dinheiro valor)
{
Id = id;
Fabricacao = fabricacao;
Tamanho = tamanho ?? throw new ArgumentNullException(nameof(tamanho));
Valor = valor ?? throw new ArgumentNullException(nameof(valor));
}
internal override ILimiteDeRemuneracao Construir(IUnidadeDeEntrega valorLimite, bool podeAbaterFechadas = false)
{
if (!(valorLimite is Dinheiro))
{
throw new ArgumentException("LimiteDoTipoMonetarioMinimo so pode utilizar valores limites em forma de dinheiro");
}
Dinheiro limite = (Dinheiro)valorLimite;
return(new LimiteMinimoPorValorMonetario(limite, podeAbaterFechadas));
}
internal override IMetaConstruivel Construir(IUnidadeDeEntrega valorDaMeta, decimal percentualBonus, decimal percentualPenalizacao)
{
if (!(valorDaMeta is Dinheiro))
{
throw new ArgumentException("MetaDoTipoMonetarioMinimo so pode utilizar valores limites em forma de dinheiro");
}
Dinheiro meta = (Dinheiro)valorDaMeta;
return(new MetaMonetariaMaximaPorPercentualSobreOTodo(meta, percentualBonus, percentualPenalizacao));
}
public void Deve_Receber_Params_E_Retornar_Nulo()
{
var id = Guid.NewGuid();
var tamanho = new Tamanho(122.53M, "KG");
var fabricacao = Fabricacao.Importado;
var valor = new Dinheiro(25.95M);
var result = new Produto(id, tamanho, fabricacao, valor);
Assert.IsNull(result, "Objeto deve ser nulo");
}
public static void Receber(int valor)
{
int dinheiro = Dinheiro.ObterValor() + valor;
if (dinheiro >= 9999999)
{
dinheiro = 9999999;
}
GameObject.Find("Dinheiro").transform.FindChild("Valor").GetComponent <GUIText>().text = dinheiro.ToString();
}
public static void PagamentoAVista()
{
Console.WriteLine("À vista você ainda tem 10% de desconto no valor final da sua compra :) ");
Console.WriteLine("O total da Sua compra foi: " + ValorCompra);
Console.WriteLine("Informe o valor recebido: ");
double valorRecebido = Double.Parse(Console.ReadLine());
var pagamentoAvista = new Dinheiro(ValorCompra, valorRecebido);
pagamentoAvista.Pagar();
historicoAVista.Add(pagamentoAvista);
}
private void CorrecaoDeArredondamentoDeExcedente(IRemuneracao remuneracao, Dinheiro diferencaDeExcedente)
{
var remuneracaoLimitada = remuneracao as IRemuneracaoLimitada;
IExcedenteDeRemuneracao excedente = remuneracaoLimitada.Excedentes.Last();
remuneracaoLimitada.RemoverExcedente(excedente);
IExcedenteDeRemuneracao novoExcedente = new ExcedenteDeRemuneracao(remuneracaoLimitada, excedente.Limite, excedente.ValorBruto, valorExcedenteAoLimiteDestaRemuneracao: excedente.ValorExcedente + diferencaDeExcedente);
remuneracaoLimitada.AdicionarExcedente(novoExcedente);
}
public static IFechamentoDeRemuneracao ConfiguraFechamentoMock(IFechamentoDeRemuneracao fechamento, int idAdicional = 0)
{
Dinheiro valorBruto = fechamento.ValorBruto;
Dinheiro valorLiquido = fechamento.ValorLiquido;
Dinheiro desconto = fechamento.Desconto;
Dinheiro bonus = fechamento.Bonus;
int idFavorecido = fechamento.LancamentosDeRemuneracao.First().IdFavorecido;
int idConta = fechamento.ContaExecutoraDoInicioDoFechamento;
int id = fechamento.Id + idAdicional;
IFechamentoDeRemuneracao fechamentoNovo = FabricaDeFechamentos.CriaFechamento(id, ConfiguraLancamentosDeFechamento(idFavorecido, valorBruto, valorLiquido), idConta);
return(fechamentoNovo);
}
public void Valor_Ajustado_Deve_Ser_Calculado_A_Partir_Do_Valor_Bruto_Da_Remuneracao(IFechamentoDeRemuneracao fechamentoDeRemuneracao, Dinheiro desconto, Dinheiro bonus)
{
//Arrange
Initialize(fechamentoDeRemuneracao);
Dinheiro valorBruto = fechamentoDeRemuneracao.ValorBruto;
Dinheiro ajuste = bonus - desconto;
//Act
_diretor.AplicaAjustesA(fechamentoDeRemuneracao.Id, desconto, bonus).Wait();
IFechamentoDeRemuneracao remuneracaoAjustada = _repositorio.ObtemFechamento(fechamentoDeRemuneracao.Id).WaitForResult();
//Assert
Assert.AreEqual(remuneracaoAjustada.ValorBruto, remuneracaoAjustada.ValorLiquido - ajuste);
}
public Remuneracao(int id, Dinheiro valorARemunerar, int iDFavorecido, Competencia competencia,
Vinculacao vinculacao, DateTime dataDaEntrega, bool foiFechada, string nomeFavorecido = null
, IRegraDeRemuneracao regraGeradora = null)
{
Id = id;
ValorAjustado = valorARemunerar;
IdFavorecido = iDFavorecido;
CompetenciaDaEntrega = competencia;
RegraGeradora = regraGeradora;
Vinculacao = vinculacao;
DataDaEntrega = dataDaEntrega;
FoiFechada = foiFechada;
NomeFavorecido = nomeFavorecido;
}
private ConstrutorDeRegraDeRemuneracaoFixaPorValor ConstruirValorPagamento(dynamic valorPagamento)
{
dynamic idMoeda = valorPagamento["Moeda"]["Id"];
decimal valor = decimal.Parse(valorPagamento["Valor"].ToString());
Moeda moeda = Moeda.Obtem(idMoeda.ToString());
Dinheiro valorRegra = new Dinheiro(valor, moeda);
//JsonSerializerSettings settingsSerializer = new JsonSerializerSettings() { ContractResolver = new JsonContractResolverDeModelosBase() };
//_regraConstruida.ValorDoPagamento = JsonConvert.DeserializeObject<Dinheiro>(valorRegra, settingsSerializer);
_regraConstruida.ValorDoPagamento = valorRegra;
return(this);
}
public Dinheiro ObterRendaTotal()
{
var dinheiroTotal = Dinheiro.CriarNovo(0);
foreach (var pessoa in Pessoas)
{
if (!pessoa.PossuiRenda())
{
continue;
}
dinheiroTotal = pessoa.Renda.Somar(dinheiroTotal);
}
return(dinheiroTotal);
}
//TODO Melhorar reutilizacao de codigo usando pattern Template - note que a funcao aplica limites é idêntica para o limite máximo e o mínimo
internal override IEnumerable <IRemuneracao> LimitaRemuneracoesDoContexto(IEnumerable <IRemuneracao> remuneracoesPorContextoDeAcumulacao)
{
IEnumerable <IRemuneracao> remuneracoesLimitadasNoContexto = null;
Dinheiro totalDaRemuneracao = new Dinheiro();
totalDaRemuneracao = remuneracoesPorContextoDeAcumulacao.Select(rem => rem is IRemuneracaoLimitada ? rem.ValorBruto : rem.ValorAjustado).SomaDinheiro();
Dinheiro valorJaExcedido = ObtemTotalExcedidoDesteLimite(remuneracoesPorContextoDeAcumulacao);
Dinheiro valorExcedente = Dinheiro.MenorEntre(_valorLimite, totalDaRemuneracao);
IEnumerable <IRemuneracao> remuneracoesDisponiveisParaAbatimento = remuneracoesPorContextoDeAcumulacao.Where(rem => !rem.FoiEmitida && (!rem.FoiFechada || _podeAbaterFechadas));
remuneracoesLimitadasNoContexto = FormaDeAbatimento.AbaterValorExcedenteDasRemuneracoes(this, remuneracoesDisponiveisParaAbatimento, valorExcedente);
return(remuneracoesLimitadasNoContexto);
}