Verwendung von Tabellen und Formeln

Implementieren der Beitragsberechnung

In diesem Kapitel werden wir nun die Beitragsberechnung für unsere Hausratprodukte implementieren.

Wir erweitern unser Modell um die Methoden gemäß der folgenden Abbildung.

Modell Berechnungsmehoden

Abbildung 7: Berücksichtigung der Beitragsberechnung im Modell

Jede Deckung hat einen Jahresbasisbeitrag (/jahresbasisbeitrag). Der Jahresbasisbeitrag des Vertrags ist die Summe über die Jahresbasisbeiträge seiner Deckungen.

Der Nettobeitrag je Zahlungsperiode (/nettobeitragZw) ist der vom Beitragszahler zu zahlende Beitrag ohne Versicherungssteuer. Er ergibt sich aus dem Jahresbasisbeitrag dividiert durch Anzahl der Zahlungsperioden und multipliziert mit 1+Höhe des Ratenzahlungszuschlages.

Der Bruttobeitrag je Zahlungsweise (/bruttobeitragZw) ist der vom Beitragszahler zu zahlende Bruttobeitrag pro Zahlung. Er ergibt sich aus der Multiplikation des NettobeitragZw mit 1+Versicherungssteuersatz. In dem Tutorial verwenden wir Ratenzahlungszuschlag in Höhe von 3% und Versicherungssteuer von 19%.

Legen Sie nun die neuen Attribute in den Klassen HausratVertrag und HausratGrunddeckung an. Um die HausratZusatzdeckungen kümmern wir uns im nächsten Kapitel. Alle Attribute sind abgeleitet (cached, Berechnung durch expliziten Methodenaufruf) und vom Datentyp Money. Da es sich um ein gecachedes, abgeleitetes Attribut handelt, generiert Faktor-IPS® je eine Membervariable und eine Gettermethode.

Die Berechnung aller Beitragsattribute erfolgt durch die Methode berechneBeitrag() der Klasse HausratVertrag. Die Methode berechnet dabei alle Beitragsattribute des Vertrags und auch den Jahresbasisbeitrag der Deckungen. Hierzu verwendet sie natürlich die Methode berechneJahresbasisbeitrag() der Deckungen.

Als nächstes legen wir diese Methoden an. Öffnen Sie die Klasse „HausratVertrag“, im Editor wechseln Sie auf die zweite Seite „Verhalten“ (analog wie in Abbildung 5). Im Bereich „Methoden“ drücken Sie auf Button „Neu“, geben den Namen für die Methode ein und drücken auf Button „OK“. Die folgende Abbildung zeigt den Dialog zum Bearbeiten einer Methodensignatur.

dialog methodensignatur

Abbildung 8: Dialog zum Bearbeiten einer Methodensignatur

Im Vergleich zur Modellierung von Beziehungen und Attributen bietet die Codegenerierung für Methoden weniger Vorteile. Methoden können daher natürlich auch direkt im Sourcecode definiert werden. Wir gehen i.d.R. einen Mittelweg indem wir Methoden des published Interface zur besseren Dokumentation in Faktor-IPS® erfassen und modellinterne Methoden ausschließlich im Sourcecode definieren.

Der folgende Sourcecodeausschnitt zeigt die Implementierung der spartenübergreifenden Beitragsberechnung in der Klasse HausratVertrag. Aus Übersichtlichkeitsgründen implementieren wir die Berechnung von Jahresbasisbeitrag und NettobeitragZw in zwei eigenen privaten Methoden, die wir direkt in den Sourcecode schreiben, ohne sie ins Modell aufzunehmen.

/**
 * @generated NOT
 */
public void berechneBeitrag() {
	berechneJahresbasisbeitrag();
	berechneNettobeitragZw();
	Decimal versSteuerFaktor = Decimal.valueOf(119, 2);
	// 1+Versicherungssteuersatz=1.19 (119 Prozent)
	bruttobeitragZw = nettobeitragZw.multiply(versSteuerFaktor, BigDecimal.ROUND_HALF_UP);
}

/**
 * @generated NOT
 */

private void berechneJahresbasisbeitrag() {
	jahresbasisbeitrag = Money.euro(0, 0);
	HausratGrunddeckung hausratGrunddeckung = getHausratGrunddeckung();

	hausratGrunddeckung.berechneJahresbasisbeitrag();
	jahresbasisbeitrag = jahresbasisbeitrag.add(hausratGrunddeckung.getJahresbasisbeitrag());
	/*
	 * TODO: wenn das Modell um Zusatzdeckungen erweitert wird, muss deren
	 * Beitrag an dieser Stelle natürlich auch hinzuaddiert werden
	 */
}
private void berechneNettobeitragZw() {
	if (zahlweise == null) {
		nettobeitragZw = Money.NULL;
		return;
	}
	if (zahlweise.intValue() == 1) {
		nettobeitragZw = jahresbasisbeitrag;
	} else {
		Decimal rzFaktor = Decimal.valueOf(103, 2);
		// 1+ratenzahlungszuschlag=1.03 (103 Prozent)
		nettobeitragZw = jahresbasisbeitrag.multiply(rzFaktor, BigDecimal.ROUND_HALF_UP);
	}
	nettobeitragZw = nettobeitragZw.divide(zahlweise.intValue(), BigDecimal.ROUND_HALF_UP);
}

Legen Sie zudem ein neues Attribut mit dem Namen wirksamAb vom Typ GregorianCalender in dem Editor der Klasse HausratVertrag an. Der generierte Sourcecode der Setter- und Gettermethode sollte wie folgt aussehen.

/**
 * Gibt den Wert des Attributs WirksamAb zurueck.
 *
 * @generated
 */
@IpsAttribute(name = "WirksamAb", kind = AttributeKind.CHANGEABLE, valueSetKind = ValueSetKind.AllValues)
public GregorianCalendar getWirksamAb() {
	return wirksamAb == null ? null : (GregorianCalendar) wirksamAb.clone();
}

/**
 * Setzt den Wert des Attributs WirksamAb.
 *
 * @generated
 */
@IpsAttributeSetter("WirksamAb")
public void setWirksamAb(GregorianCalendar newValue) {
	this.wirksamAb = newValue == null ? null : (GregorianCalendar) newValue.clone();
}

Außerdem sollte die generierte Methode getEffectiveFromAsCalendar() das Wirksamkeitsdatum zurück geben. Hier sehen wir den generierten Sourcecode.

/**
 * {@inheritDoc}
 *
 * @generated
 */
@Override
public Calendar getEffectiveFromAsCalendar() {
	// TODO Implementieren des Zugriffs auf das Wirksamkeitsdatum (wird benoetigt um
	// auf die gueltigen Produktdaten zuzugreifen).
	// Damit diese Methode bei erneutem Generieren nicht neu ueberschrieben wird,
	// muss im Javadoc ein NOT hinter @generated geschrieben werden!
	return null;
}

Ändern Sie die Methode wie folgt.

/**
 * {@inheritDoc}
 *
 * @generated NOT
 */
@Override
public Calendar getEffectiveFromAsCalendar() {
	return getWirksamAb();
}

Beitragsberechnung für die Hausrat-Deckungen

Für die Hausratversicherung muss nun die Beitragsberechnung auf Deckungsebene implementiert werden.

Der Jahresbasisbeitrag für die Grunddeckung wird wie folgt berechnet:

  • Ermittlung des Beitragssatzes pro 1000 Euro Versicherungssumme aus der Tariftabelle.

  • Division der Versicherungssumme durch 1000 Euro und Multiplikation mit dem Beitragssatz.

Da sich diese Berechnungsvorschrift nicht ändert, implementieren wir sie direkt in der Javaklasse HausratGrunddeckung. Bei den Zusatzversicherungen werden wir dann der Fachabteilung erlauben den Jahresbasisbeitrag über Berechnungsformeln festzulegen.

Zunächst definieren wir die Methode berechneJahresbasisbeitrag() im Editor der HausratGrunddeckung (mit Access Modifier published).

anlegen methode

Abbildung 9: Anlegen der Methode berechneJahresbasisbeitrag

Öffnen Sie nun die Javaklasse im Editor und implementieren Sie die Methode wie folgt:

/**
 * @generated NOT
 */
public void berechneJahresbasisbeitrag() {
	TariftabelleHausrat tabelle = getTariftabelle();
	TariftabelleHausratRow row = null;
	if (tabelle != null) {
		row = tabelle.findRow(getHausratVertrag().getTarifzone());
	}
	if (row == null) {
		jahresbasisbeitrag = Money.NULL;
		return;
	}
	Money vs = getHausratVertrag().getVersSumme();
	Decimal beitragssatz = row.getBeitragssatz();
	jahresbasisbeitrag = vs.divide(1000, BigDecimal.ROUND_HALF_UP).multiply(beitragssatz, BigDecimal.ROUND_HALF_UP);
}

Wir testen die Beitragsberechung indem wir wieder unseren JUnit-Test erweitern.

@Test
public void testBerechneBeitrag() {
	// Erzeugen eines hausratvertrags mit der Factorymethode des Produktes
	HausratVertrag vertrag = kompaktProdukt.createHausratVertrag();

	// Wirksamkeitsdatum des Vertrages setzen, damit die ProduktAnpassungsstufe
	// gefunden wird!
	// Dies muss nach dem Gueltigkeitsbeginn der Anpassungsstufe liegen!
	vertrag.setWirksamAb(new GregorianCalendar(2015, 9, 14));

	// Vertragsattribute setzen
	vertrag.setPlz("45525"); // => tarifzone 3
	vertrag.setVersSumme(Money.euro(60000));
	vertrag.setZahlweise(new Integer(2)); // halbjaehrlich

	// Grunddeckungstyp holen, der dem Produkt in der Anpassungsstufe zugeordnet ist.
	HausratGrunddeckungstyp deckungstyp = kompaktAnpStufe.getHausratGrunddeckungstyp();

	// Grunddeckung erzeugen und zum Vertag hinzufuegen
	HausratGrunddeckung deckung = vertrag.newHausratGrunddeckung(deckungstyp);

	// Beitrag berechnen und Ergebniss pruefen
	vertrag.berechneBeitrag();

	// tarifzone 3 => beitragssatz = 1.21
	// jahresbasisbeitrag = versicherungsumme / 1000 * beitragssatz = 60000 / 1000 * 1,21 = 72,60
	assertEquals(Money.euro(72, 60), deckung.getJahresbasisbeitrag());

	// Jahresbasisbeitrag vertrag = Jahresbasisbeitrag deckung
	assertEquals(Money.euro(72, 60), vertrag.getJahresbasisbeitrag());

	// NettobeitragZw = 72,60 / 2 * 1,03 (wg. Ratenzahlungszuschlag von 3%) = 37,389 => 37,39
	assertEquals(Money.euro(37, 39), vertrag.getNettobeitragZw());

	// BruttobeitragZw = 37,39 * Versicherungssteuersatz = 37,39 * 1,19 = 44,49
	assertEquals(Money.euro(44, 49), vertrag.getBruttobeitragZw());
}