CLOSE #80 Add phases summary to electric meter

src/main/java/pl/grzeslowski/jsupla/api/channel/state/ElectricityMeterState.java

@@ -10,33 +10,115 @@ public interface ElectricityMeterState extends State {
 
     String getCurrency();
 
+    PhasesSummary getPhasesSummary();
+
     SortedSet<Phase> getPhases();
 
+    interface PhasesSummary {
+        int getNumberOfPhases();
+
+        /**
+         * Frequency in <code>Hz</code>.
+         */
+        BigDecimal getFrequency();
+
+        /**
+         * Active power in <code>W</code>
+         */
+        BigDecimal getPowerActive();
+
+        /**
+         * Reactive power in <code>var</code>
+         */
+        BigDecimal getPowerReactive();
+
+        /**
+         * Apparent power in <code>VA</code>
+         */
+        BigDecimal getPowerApparent();
+
+        /**
+         * Total forward active energy in <code>kWh</code>
+         */
+        BigDecimal getTotalForwardActiveEnergy();
+
+        /**
+         * Total reverse active energy in <code>kWh</code>
+         */
+        BigDecimal getTotalReverseActiveEnergy();
+
+        /**
+         * Total forward reactive energy in <code>kvarh</code>
+         */
+        BigDecimal getTotalForwardReactiveEnergy();
+
+        /**
+         * Total reverse reactive energy in <code>kvarh</code>
+         */
+        BigDecimal getTotalReverseReactiveEnergy();
+    }
+
     interface Phase extends Comparable<Phase> {
         int getNumber();
 
+        /**
+         * Frequency in <code>Hz</code>.
+         */
         BigDecimal getFrequency();
 
+        /**
+         * Voltage in <code>V</code>
+         */
         BigDecimal getVoltage();
 
+        /**
+         * Current in <code>A</code>
+         */
         BigDecimal getCurrent();
 
+        /**
+         * Active power in <code>W</code>
+         */
         BigDecimal getPowerActive();
 
+        /**
+         * Reactive power in <code>var</code>
+         */
         BigDecimal getPowerReactive();
 
+        /**
+         * Apparent power in <code>VA</code>
+         */
         BigDecimal getPowerApparent();
 
+        /**
+         * Power factor. No unit
+         */
         BigDecimal getPowerFactor();
 
+        /**
+         * Phase angle in <code>°</code>
+         */
         BigDecimal getPhaseAngle();
 
+        /**
+         * Total forward active energy in <code>kWh</code>
+         */
         BigDecimal getTotalForwardActiveEnergy();
 
+        /**
+         * Total reverse active energy in <code>kWh</code>
+         */
         BigDecimal getTotalReverseActiveEnergy();
 
+        /**
+         * Total forward reactive energy in <code>kvarh</code>
+         */
         BigDecimal getTotalForwardReactiveEnergy();
 
+        /**
+         * Total reverse reactive energy in <code>kvarh</code>
+         */
         BigDecimal getTotalReverseReactiveEnergy();
 
         @Override

src/main/java/pl/grzeslowski/jsupla/api/internal/ElectricityMeterStateImpl.java

@@ -11,13 +11,65 @@
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 
+import static java.math.RoundingMode.CEILING;
+
 @Value
 class ElectricityMeterStateImpl implements ElectricityMeterState {
     BigDecimal totalCost;
     BigDecimal pricePerUnit;
     String currency;
+    PhasesSummary phasesSummary;
     SortedSet<Phase> phases;
 
+    private static BigDecimal computeFrequency(final SortedSet<Phase> phases) {
+        final BigDecimal frequencySum = phases.stream()
+                                                .map(Phase::getFrequency)
+                                                .reduce(BigDecimal.ZERO, BigDecimal::add);
+        return frequencySum.divide(new BigDecimal(phases.size()), 2, CEILING);
+    }
+
+    private static BigDecimal computePowerActive(final SortedSet<Phase> phases) {
+        return phases.stream()
+                       .map(Phase::getPowerActive)
+                       .reduce(BigDecimal.ZERO, BigDecimal::add);
+    }
+
+    private static BigDecimal computePowerReactive(final SortedSet<Phase> phases) {
+        return phases.stream()
+                       .map(Phase::getPowerReactive)
+                       .reduce(BigDecimal.ZERO, BigDecimal::add);
+    }
+
+    private static BigDecimal computePowerApparent(final SortedSet<Phase> phases) {
+        return phases.stream()
+                       .map(Phase::getPowerApparent)
+                       .reduce(BigDecimal.ZERO, BigDecimal::add);
+    }
+
+    private static BigDecimal computeTotalForwardActiveEnergy(final SortedSet<Phase> phases) {
+        return phases.stream()
+                       .map(Phase::getTotalForwardActiveEnergy)
+                       .reduce(BigDecimal.ZERO, BigDecimal::add);
+    }
+
+    private static BigDecimal computeTotalReverseActiveEnergy(final SortedSet<Phase> phases) {
+        return phases.stream()
+                       .map(Phase::getTotalReverseActiveEnergy)
+                       .reduce(BigDecimal.ZERO, BigDecimal::add);
+    }
+
+    private static BigDecimal computeTotalForwardReactiveEnergy(final SortedSet<Phase> phases) {
+        return phases.stream()
+                       .map(Phase::getTotalForwardReactiveEnergy)
+                       .reduce(BigDecimal.ZERO, BigDecimal::add);
+    }
+
+    private static BigDecimal computeTotalReverseReactiveEnergy(final SortedSet<Phase> phases) {
+        return phases.stream()
+                       .map(Phase::getTotalReverseReactiveEnergy)
+                       .reduce(BigDecimal.ZERO, BigDecimal::add);
+    }
+
     public ElectricityMeterStateImpl(final Channel channel) {
         final ChannelState state = channel.getState();
         totalCost = state.getTotalCost();
@@ -41,11 +93,36 @@ public ElectricityMeterStateImpl(final Channel channel) {
                                            .totalReverseReactiveEnergy(p.getTotalReverseReactiveEnergy())
                                            .build())
                          .collect(Collectors.toCollection(TreeSet::new));
+        phasesSummary = PhasesSummaryImpl.builder()
+                                .numberOfPhases(phases.size())
+                                .frequency(computeFrequency(phases))
+                                .powerActive(computePowerActive(phases))
+                                .powerReactive(computePowerReactive(phases))
+                                .powerApparent(computePowerApparent(phases))
+                                .totalForwardActiveEnergy(computeTotalForwardActiveEnergy(phases))
+                                .totalReverseActiveEnergy(computeTotalReverseActiveEnergy(phases))
+                                .totalForwardReactiveEnergy(computeTotalForwardReactiveEnergy(phases))
+                                .totalReverseReactiveEnergy(computeTotalReverseReactiveEnergy(phases))
+                                .build();
+    }
+
+    @Builder
+    @Value
+    private static class PhasesSummaryImpl implements PhasesSummary {
+        int numberOfPhases;
+        BigDecimal frequency;
+        BigDecimal powerActive;
+        BigDecimal powerReactive;
+        BigDecimal powerApparent;
+        BigDecimal totalForwardActiveEnergy;
+        BigDecimal totalReverseActiveEnergy;
+        BigDecimal totalForwardReactiveEnergy;
+        BigDecimal totalReverseReactiveEnergy;
     }
 
     @Builder
     @Value
-    static class PhaseImpl implements Phase {
+    private static class PhaseImpl implements Phase {
         int number;
         BigDecimal frequency;
         BigDecimal voltage;

version.properties

@@ -1,4 +1,4 @@
 #Version of the produced binaries. This file is intended to be checked-in.
 #It will be automatically bumped by release automation. 
-version=3.9.2
+version=3.10.0
 previousVersion=3.9.1