Package: SerienTerminFactory

SerienTerminFactory

name	instruction	branch	complexity	line	method
lambda$parse$0(KalenderEintragGenerell, String)	M: 5 C: 25 83%	M: 1 C: 3 75%	M: 1 C: 3 75%	M: 1 C: 4 80%	M: 0 C: 1 100%
parse(String)	M: 12 C: 68 85%	M: 1 C: 1 50%	M: 1 C: 1 50%	M: 1 C: 11 92%	M: 0 C: 1 100%
static {...}	M: 0 C: 19 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 3 100%	M: 0 C: 1 100%

Coverage

1: package auftraege.factory;
2:
3: import tec.uom.se.ComparableQuantity;
4: import tec.uom.se.quantity.Quantities;
5: import tec.uom.se.unit.Units;
6: import util.RegexConstants;
7: import util.exceptions.ExceptionConstants;
8: import util.exceptions.SollteNichtPassierenException;
9: import zeit.eintraege.KalenderEintragGenerell;
10: import zeit.eintraege.KalenderEintragTyp;
11: import zeit.serientermin.SerienTermin;
12:
13: import javax.measure.quantity.Time;
14: import java.time.LocalDate;
15: import java.time.LocalDateTime;
16: import java.time.format.DateTimeFormatter;
17: import java.util.Optional;
18: import java.util.regex.Matcher;
19: import java.util.regex.Pattern;
20:
21: /**
22: * Ermöglicht es einen KalenderEintag zu erstellen.
23: */
24: public enum SerienTerminFactory implements DirectVoraussichtlicheDokumentenklassenVariablenFactory<SerienTermin> {
25:         INSTANCE;
26:         private static final int TURNUS_GRUPPE = 3;
27:         private static final int PLUSTAGE_GRUPPE = 2;
28:         private static final int DATUM_GRUPPE = 1;
29:
30:         private static final ComparableQuantity<Time> MONATS_GESCHUMMEL = Quantities.getQuantity(-1, Units.DAY);
31:
32:         @Override
33:         public SerienTermin parse(final String wert) {
34:                 final Pattern pattern = Pattern.compile(RegexConstants.DATUM.pattern() + "\\s*\\+?\\s*" + RegexConstants.ZAHL + "?\\s*" + "(jährlich|monatlich|wöchentlich)?");
35:                 final Matcher matcher = pattern.matcher(wert);
36:
37:•                if (matcher.find()) {
38:                         final LocalDateTime datum = LocalDate.parse(matcher.group(SerienTerminFactory.DATUM_GRUPPE), DateTimeFormatter.ofPattern("dd.MM.yyyy")).atStartOfDay();
39:
40:                         final ComparableQuantity<Time> plusTage = Quantities.getQuantity(
41:                                         Optional.ofNullable(matcher.group(SerienTerminFactory.PLUSTAGE_GRUPPE))
42:                                                         .map(Integer::valueOf)
43:                                                         .orElse(0) + 1,
44:                                         Units.DAY);
45:
46:                         final KalenderEintragGenerell eintrag = KalenderEintragGenerell.create(datum, plusTage, KalenderEintragTyp.VERFUEGBAR);
47:
48:                         return Optional.ofNullable(matcher.group(SerienTerminFactory.TURNUS_GRUPPE)).map(s -> {
49:•                                switch (s) {
50:                                         case "jährlich":
51:                                                 return SerienTermin.createSerienterminMitIntervall(eintrag, Quantities.getQuantity(1, Units.YEAR));
52:                                         case "monatlich":
53:                                                 return SerienTermin.createMonatlichenSerientermin(eintrag);
54:                                         case "wöchentlich":
55:                                                 return SerienTermin.createSerienterminMitIntervall(eintrag, Quantities.getQuantity(1, Units.WEEK));
56:                                         default:
57:                                                 throw new SollteNichtPassierenException("das hier passiert nicht!");
58:                                 }
59:                         }).orElse(SerienTermin.createSerienterminMitIntervall(eintrag, Quantities.getQuantity(Integer.MAX_VALUE, Units.YEAR)));
60:
61:                 } else {
62:                         throw new IllegalArgumentException(String.format(ExceptionConstants.NOT_PARSABLE, wert));
63:                 }
64:         }
65: }