public async Task AltersguthabenEndeJahrTest(int gemeldeterLohnAsInt, string dateOfBirthAsString,
string dateOfEintrittAsString, int einlageAsDouble, double expectedEndaltersguthabenAsDouble)
{
// given
decimal gemeldeterLohn = gemeldeterLohnAsInt;
decimal einlage = Convert.ToDecimal(einlageAsDouble);
DateTime dateOfBirth = DateTime.Parse(dateOfBirthAsString, CultureInfo.InvariantCulture);
DateTime dateOfEintritt = DateTime.Parse(dateOfEintrittAsString, CultureInfo.InvariantCulture);
decimal expectedEndaltersguthaben = Convert.ToDecimal(expectedEndaltersguthabenAsDouble);
var input = new BvgCalculationInput
{
Lohn = gemeldeterLohn,
DateOfEintritt = dateOfEintritt,
DateOfBirth = dateOfBirth,
Altersguthaben = einlage,
Geschlecht = Geschlecht.Mann,
};
// when
var plan = new BvgPlan();
var result = await _calculator.CalculateAsync(plan, input).ConfigureAwait(false);
// then
result.AlterguthabenEndeJahr.Should().Be(expectedEndaltersguthaben);
}
public async Task AltersgutschriftTest(int gemeldeterLohnAsInt, double expectedAltersgutschriftAsDouble, string dateOfBirthAsString)
{
_outputHelper.WriteLine($"Lohn={gemeldeterLohnAsInt}, AGS={expectedAltersgutschriftAsDouble}, DoB={dateOfBirthAsString}");
// given
decimal gemeldeterLohn = gemeldeterLohnAsInt;
decimal expectedAltersgutschrift = Convert.ToDecimal(expectedAltersgutschriftAsDouble);
DateTime dateOfBirth = DateTime.Parse(dateOfBirthAsString, CultureInfo.InvariantCulture);
var input = new BvgCalculationInput
{
Lohn = gemeldeterLohn,
DateOfEintritt = new DateTime(2016, 1, 1),
DateOfBirth = dateOfBirth,
Altersguthaben = 0m,
Geschlecht = Geschlecht.Mann,
};
var calculator = _kernel.Get <IBvgCalculator>();
var plan = new BvgPlan();
// when
var result = await calculator.CalculateAsync(plan, input).ConfigureAwait(false);
// then
result.Altersgutschrift.Should().Be(expectedAltersgutschrift);
}
public Tuple <DateTime, decimal> Calculate(BvgPlan plan, BvgCalculationInput input)
{
int schlussalter = _calcSchlussalter.Calculate(plan, input);
DateTime dateOfRetirement = _calcPensionierung.Calculate(plan, input);
int rechnungsjahr = input.DateOfEintritt.Year;
int bvgAlter = rechnungsjahr - input.DateOfBirth.Year;
bool isPensionierungInRechnungsjahr = bvgAlter == schlussalter;
var endOfYear = new DateTime(rechnungsjahr, 1, 1);
if (isPensionierungInRechnungsjahr)
{
endOfYear = dateOfRetirement;
}
decimal aghEndeJahr = 0;
if (bvgAlter >= plan.Eintrittsalter)
{
decimal schrumpPeriodeRechnungsjahr = (isPensionierungInRechnungsjahr ? dateOfRetirement.Month / 12m : 1m);
decimal agsRechnungsjahr = _calcAltersgutschrift.Calculate(plan, input) * schrumpPeriodeRechnungsjahr;
aghEndeJahr = agsRechnungsjahr + input.Altersguthaben * (1m + _constantsBvg.BvgZins * schrumpPeriodeRechnungsjahr);
}
return(Tuple.Create(endOfYear, aghEndeJahr));
}
public decimal Calculate(BvgPlan plan, BvgCalculationInput input)
{
int financialYear = input.DateOfEintritt.Year;
int xBvg = financialYear - input.DateOfBirth.Year;
return(GetGutschriftssatz(xBvg, input.Geschlecht, plan));
}
public Dictionary <DateTime, decimal> Calculate(BvgPlan plan, BvgCalculationInput input)
{
var dictProjection = new Dictionary <DateTime, decimal>();
var aghEndeJahr = _calcAlterguthabenEndeJahr.Calculate(plan, input);
return(dictProjection);
}
public DateTime Calculate(BvgPlan plan, BvgCalculationInput input)
{
int schlussalter = _calcSchlussalter.Calculate(plan, input);
DateTime dateOfRetirement = new DateTime(input.DateOfBirth.Year, input.DateOfBirth.Month, 1).AddMonths(1).AddYears(schlussalter).AddDays(-1);
return(dateOfRetirement);
}
public BvgCalculationInput GetDetails([FromBody] BvgCalculationInput input)
{
var engine = new BvgCalculator(new BvgConstants());
var result = engine.CalculateAsync(new BvgPlan(), input);
return(result);
}
public async Task <BvgCalculationResult> CalculateAsync(BvgPlan plan, BvgCalculationInput input)
{
BvgCalculationResult result = new BvgCalculationResult();
result.VersicherterLohn = _calcVersicherterLohn.Calculate(plan, input);
result.Altersgutschrift = _calcAltersgutschrift.Calculate(plan, input);
result.AlterguthabenEndeJahr = _calcAlterguthabenEndeJahr.Calculate(plan, input).Item2;
result.Altersrente = 1000m;
return(await Task.FromResult(result));
}
public decimal Calculate(BvgPlan plan, BvgCalculationInput input)
{
var jahreslohn = _calcJahreslohn.Calculate(plan, input);
if (jahreslohn <= _calcLohnuntergrenze.Calculate(plan, input))
{
return(0m);
}
decimal lohn = Math.Max(jahreslohn - _calcKoordinationsabzug.Calculate(plan, input), _calcMinimumLohn.Calculate(plan, input));
return(lohn);
}
private static void CalculateHelper(BvgCalculationInput input, BvgPlan plan, IBvgCalculator engine, List <BvgTestData> resultList)
{
var result =
Task.Factory.StartNew(s => engine.CalculateAsync(plan, input), engine, CancellationToken.None,
TaskCreationOptions.None, TaskScheduler.Default)
.Unwrap().GetAwaiter().GetResult();
resultList.Add(new BvgTestData()
{
Input = input,
Result = result,
});
}
public int Calculate(BvgPlan plan, BvgCalculationInput input)
{
int schlussalter = 0;
switch (input.Geschlecht)
{
case Geschlecht.Frau:
{
schlussalter = plan.SchlussalterFrau;
}
break;
case Geschlecht.Mann:
{
schlussalter = plan.SchlussalterMann;
}
break;
}
return(schlussalter);
}
public async Task VersicherterLohnTest(int gemeldeterLohnAsInt, int expectedVersicherterLohnAsInt)
{
// given
decimal gemeldeterLohn = gemeldeterLohnAsInt;
decimal expectedVersicherterLohn = expectedVersicherterLohnAsInt;
var input = new BvgCalculationInput
{
Lohn = gemeldeterLohn,
DateOfEintritt = new DateTime(2016, 1, 1),
DateOfBirth = new DateTime(1969, 3, 17),
Altersguthaben = 0m,
Geschlecht = Geschlecht.Mann,
};
var calculator = _kernel.Get <IBvgCalculator>();
var plan = new BvgPlan();
// when
var result = await calculator.CalculateAsync(plan, input).ConfigureAwait(false);
// then
result.VersicherterLohn.Should().Be(expectedVersicherterLohn);
}
public decimal Calculate(BvgPlan plan, BvgCalculationInput input)
{
return(0.75m * _calcAhv.GetMaxRente(input.DateOfEintritt.Year));
}
static void Main()
{
var resultList = new List <BvgTestData>();
var plan = new BvgPlan();
var engine = new BvgCalculator(new BvgConstants());
// Testcase 1
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Mann,
Altersguthaben = 40000m,
DateOfBirth = new DateTime(1974, 8, 15),
Lohn = 100000m,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 2
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Frau,
Altersguthaben = 45600m,
DateOfBirth = new DateTime(1965, 6, 6),
Lohn = 70000m,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 3
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Mann,
Altersguthaben = 25000m,
DateOfBirth = new DateTime(1963, 1, 24),
Lohn = 28200m,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 4
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Frau,
Altersguthaben = 44000m,
DateOfBirth = new DateTime(1965, 12, 12),
Lohn = 28200m,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 5
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Mann,
Altersguthaben = 50000m,
DateOfBirth = new DateTime(1966, 7, 25),
Lohn = 200000m,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 6
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Frau,
Altersguthaben = 29000,
DateOfBirth = new DateTime(1972, 10, 18),
Lohn = 250000,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 7
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Mann,
Altersguthaben = 30000,
DateOfBirth = new DateTime(1951, 7, 21),
Lohn = 70000,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 8
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Frau,
Altersguthaben = 21400,
DateOfBirth = new DateTime(1952, 10, 5),
Lohn = 75000,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 9
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Frau,
Altersguthaben = 0,
DateOfBirth = new DateTime(1994, 8, 31),
Lohn = 71000,
};
CalculateHelper(input, plan, engine, resultList);
}
// Testcase 10
{
BvgCalculationInput input = new BvgCalculationInput()
{
Geschlecht = Geschlecht.Mann,
Altersguthaben = 0,
DateOfBirth = new DateTime(1995, 5, 13),
Lohn = 66000,
};
CalculateHelper(input, plan, engine, resultList);
}
XmlSerializer serializer = new XmlSerializer(typeof(List <BvgTestData>));
serializer.Serialize(System.Console.Out, resultList);
}
public async Task <BvgCalculationResult> CalculateAsync(BvgPlan plan, BvgCalculationInput input)
{
DateTime calculationDate = new DateTime(2016, 1, 1);
int rechnungsjahr = calculationDate.Year;
int bvgAlter = rechnungsjahr - input.DateOfBirth.Year;
int schlussalter = 0;
switch (input.Geschlecht)
{
case Geschlecht.Frau:
{
schlussalter = plan.SchlussalterFrau;
}
break;
case Geschlecht.Mann:
{
schlussalter = plan.SchlussalterMann;
}
break;
}
bool isPensionierungInRechnungsjahr = bvgAlter == schlussalter;
DateTime dateOfRetirement = new DateTime(input.DateOfBirth.Year, input.DateOfBirth.Month, 1).AddMonths(1).AddYears(schlussalter).AddDays(-1);
decimal schrumpfPeriode = dateOfRetirement.Month / 12m;
decimal schrumpPeriodeRechnungsjahr = (isPensionierungInRechnungsjahr ? schrumpfPeriode : 1m);
decimal koordinationsabzug = _bvgConstants.MaxAhvRente * 0.875m;
decimal maxVersicherbarerLohn = 3.0m * _bvgConstants.MaxAhvRente;
decimal versicherterLohn = Math.Min(input.Lohn, maxVersicherbarerLohn) - koordinationsabzug;
var sparstaffelung = new Sparstaffelung(plan);
decimal eaghOhneZins = 0m;
decimal eaghMitZins = 0m;
var projections = new Dictionary <DateTime, decimal>();
projections.Add(calculationDate.Date, eaghMitZins + input.Altersguthaben);
// Aktuelles Jahr
if (bvgAlter >= plan.Eintrittsalter)
{
decimal agsRechnungsjahr =
versicherterLohn * sparstaffelung.GetGutschriftssatz(bvgAlter, input.Geschlecht) * schrumpPeriodeRechnungsjahr;
eaghOhneZins =
agsRechnungsjahr + input.Altersguthaben * (1m + _bvgConstants.BvgZins * schrumpPeriodeRechnungsjahr);
eaghMitZins = eaghOhneZins;
if (isPensionierungInRechnungsjahr)
{
projections.Add(dateOfRetirement.Date, eaghMitZins);
}
else
{
projections.Add(new DateTime(calculationDate.AddYears(1).Year, 1, 1).Date, eaghMitZins);
}
}
// Folgejahr ohne Schrumpjahr Pensionierung
for (int x = Math.Max(bvgAlter + 1, plan.Eintrittsalter); x < schlussalter; x++)
{
decimal ags = versicherterLohn * sparstaffelung.GetGutschriftssatz(x, input.Geschlecht);
eaghOhneZins += ags;
eaghMitZins = eaghMitZins * (1m + _bvgConstants.BvgZins) + ags;
projections.Add(new DateTime(input.DateOfBirth.Year + x, 1, 1).AddYears(1).Date, eaghMitZins);
}
// Schrumpfjahr
if (isPensionierungInRechnungsjahr == false)
{
decimal agsSchlussjahr = versicherterLohn * sparstaffelung.GetGutschriftssatz(schlussalter, input.Geschlecht);
decimal agsSchrumpfjahr = agsSchlussjahr * schrumpfPeriode;
eaghOhneZins += agsSchrumpfjahr;
eaghMitZins = eaghMitZins * (1m + _bvgConstants.BvgZins * schrumpfPeriode) + agsSchrumpfjahr;
projections.Add(dateOfRetirement, eaghMitZins);
}
var result = new BvgCalculationResult()
{
EaghMitZins = eaghMitZins,
EaghOhneZins = eaghOhneZins,
Altersrente = eaghMitZins * _bvgConstants.Umws,
Invalidenrente = eaghOhneZins * _bvgConstants.Umws * plan.FactorInvalidenrente,
Partnerrente = eaghOhneZins * _bvgConstants.Umws * plan.FactorPartnerrente,
Waisenrente = eaghOhneZins * _bvgConstants.Umws * plan.FactorWaisenrente,
};
result.Projections = projections.Select(pair => new ProjectionItem()
{
DateOfRechnungsjahr = pair.Key, Altersguthaben = pair.Value,
})
.ToArray();
return(await Task.FromResult(result));
}
public decimal Calculate(BvgPlan plan, BvgCalculationInput input)
{
decimal factorAltersgutschrift = _staffelung.Calculate(plan, input);
return(_calcVersicherterLohn.Calculate(plan, input) * factorAltersgutschrift);
}
public decimal Calculate(BvgPlan plan, BvgCalculationInput input)
{
return(Math.Min(input.Lohn, 3.0m * _calcAhv.GetMaxRente(input.DateOfEintritt.Year)));
}
