killbill-memoizeit

entitlement: Refactor and simplify EventsStream class Remove

11/2/2015 6:25:05 PM

Details

diff --git a/api/src/main/java/org/killbill/billing/entitlement/EventsStream.java b/api/src/main/java/org/killbill/billing/entitlement/EventsStream.java
index ccf1b73..b2e6d4b 100644
--- a/api/src/main/java/org/killbill/billing/entitlement/EventsStream.java
+++ b/api/src/main/java/org/killbill/billing/entitlement/EventsStream.java
@@ -56,8 +56,6 @@ public interface EventsStream {
 
     boolean isSubscriptionCancelled();
 
-    Collection<BlockingState> getCurrentSubscriptionEntitlementBlockingStatesForServices();
-
     Collection<BlockingState> getPendingEntitlementCancellationEvents();
 
     BlockingState getEntitlementCancellationEvent();
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultSubscription.java b/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultSubscription.java
index 57fc554..3667835 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultSubscription.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultSubscription.java
@@ -18,22 +18,15 @@
 
 package org.killbill.billing.entitlement.api;
 
-import java.util.Collection;
 import java.util.List;
 
 import org.joda.time.DateTime;
 import org.joda.time.LocalDate;
 
-import com.google.common.base.Predicate;
-import com.google.common.collect.Iterables;
-
 public class DefaultSubscription extends DefaultEntitlement implements Subscription {
 
-    private final Collection<BlockingState> currentSubscriptionBlockingStatesForServices;
-
     DefaultSubscription(final DefaultEntitlement entitlement) {
         super(entitlement);
-        this.currentSubscriptionBlockingStatesForServices = eventsStream.getCurrentSubscriptionEntitlementBlockingStatesForServices();
     }
 
     @Override
@@ -67,22 +60,6 @@ public class DefaultSubscription extends DefaultEntitlement implements Subscript
     }
 
     @Override
-    public String getCurrentStateForService(final String serviceName) {
-        if (currentSubscriptionBlockingStatesForServices == null) {
-            return null;
-        } else {
-            final BlockingState blockingState = Iterables.<BlockingState>tryFind(currentSubscriptionBlockingStatesForServices,
-                                                                                 new Predicate<BlockingState>() {
-                                                                                     @Override
-                                                                                     public boolean apply(final BlockingState input) {
-                                                                                         return serviceName.equals(input.getService());
-                                                                                     }
-                                                                                 }).orNull();
-            return blockingState == null ? null : blockingState.getService();
-        }
-    }
-
-    @Override
     public List<SubscriptionEvent> getSubscriptionEvents() {
         return SubscriptionEventOrdering.sortedCopy(this, getAccountTimeZone());
     }
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/DefaultEventsStream.java b/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/DefaultEventsStream.java
index 3d2e6e8..a492b0a 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/DefaultEventsStream.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/DefaultEventsStream.java
@@ -71,11 +71,6 @@ public class DefaultEventsStream implements EventsStream {
 
     private BlockingAggregator blockingAggregator;
     private List<BlockingState> subscriptionEntitlementStates;
-    private List<BlockingState> bundleEntitlementStates;
-    private List<BlockingState> accountEntitlementStates;
-    private List<BlockingState> currentSubscriptionEntitlementBlockingStatesForServices;
-    private List<BlockingState> currentBundleEntitlementBlockingStatesForServices;
-    private List<BlockingState> currentAccountEntitlementBlockingStatesForServices;
     private LocalDate entitlementEffectiveEndDate;
     private BlockingState entitlementCancelEvent;
     private EntitlementState entitlementState;
@@ -152,11 +147,6 @@ public class DefaultEventsStream implements EventsStream {
         return blockingAggregator.isBlockChange();
     }
 
-    @Override
-    public List<BlockingState> getCurrentSubscriptionEntitlementBlockingStatesForServices() {
-        return currentSubscriptionEntitlementBlockingStatesForServices;
-    }
-
     public boolean isEntitlementFutureCancelled() {
         return entitlementCancelEvent != null && entitlementCancelEvent.getEffectiveDate().isAfter(utcNow);
     }
@@ -187,34 +177,27 @@ public class DefaultEventsStream implements EventsStream {
 
     @Override
     public Collection<BlockingState> getPendingEntitlementCancellationEvents() {
-        return getPendingEntitlementEvents(DefaultEntitlementApi.ENT_STATE_CANCELLED);
-    }
 
-    @Override
-    public BlockingState getEntitlementCancellationEvent() {
-        return entitlementCancelEvent;
-    }
-
-    public Collection<BlockingState> getPendingEntitlementEvents(final String... types) {
-        final List<String> typeList = ImmutableList.<String>copyOf(types);
         return Collections2.<BlockingState>filter(subscriptionEntitlementStates,
                                                   new Predicate<BlockingState>() {
                                                       @Override
                                                       public boolean apply(final BlockingState input) {
                                                           return !input.getEffectiveDate().isBefore(utcNow) &&
-                                                                 typeList.contains(input.getStateName()) &&
+                                                                 DefaultEntitlementApi.ENT_STATE_CANCELLED.equals(input.getStateName()) &&
                                                                  (
                                                                          // ... for that subscription
                                                                          BlockingStateType.SUBSCRIPTION.equals(input.getType()) && input.getBlockedId().equals(subscription.getId()) ||
                                                                          // ... for the associated base subscription
-                                                                         BlockingStateType.SUBSCRIPTION.equals(input.getType()) && input.getBlockedId().equals(baseSubscription.getId()) ||
-                                                                         // ... for that bundle
-                                                                         BlockingStateType.SUBSCRIPTION_BUNDLE.equals(input.getType()) && input.getBlockedId().equals(bundle.getId()) ||
-                                                                         // ... for that account
-                                                                         BlockingStateType.ACCOUNT.equals(input.getType()) && input.getBlockedId().equals(account.getId())
+                                                                         BlockingStateType.SUBSCRIPTION.equals(input.getType()) && input.getBlockedId().equals(baseSubscription.getId())
                                                                  );
                                                       }
                                                   });
+
+    }
+
+    @Override
+    public BlockingState getEntitlementCancellationEvent() {
+        return entitlementCancelEvent;
     }
 
     public BlockingState getEntitlementCancellationEvent(final UUID subscriptionId) {
@@ -370,24 +353,27 @@ public class DefaultEventsStream implements EventsStream {
     private void setup() {
         computeEntitlementBlockingStates();
         computeBlockingAggregator();
-        computeEntitlementEffectiveEndDate();
         computeEntitlementCancelEvent();
         computeStateForEntitlement();
     }
 
     private void computeBlockingAggregator() {
-        currentAccountEntitlementBlockingStatesForServices = filterCurrentBlockableStatePerService(accountEntitlementStates);
-        currentBundleEntitlementBlockingStatesForServices = filterCurrentBlockableStatePerService(bundleEntitlementStates);
-        currentSubscriptionEntitlementBlockingStatesForServices = filterCurrentBlockableStatePerService(subscriptionEntitlementStates);
-        blockingAggregator = blockingChecker.getBlockedStatus(currentAccountEntitlementBlockingStatesForServices,
-                                                              currentBundleEntitlementBlockingStatesForServices,
-                                                              currentSubscriptionEntitlementBlockingStatesForServices,
+
+        final List<BlockingState> currentSubscriptionBlockingStatesForServices = filterCurrentBlockableStatePerService(BlockingStateType.SUBSCRIPTION);
+        final List<BlockingState> currentBundleBlockingStatesForServices = filterCurrentBlockableStatePerService(BlockingStateType.SUBSCRIPTION_BUNDLE);
+        final List<BlockingState> currentAccountBlockingStatesForServices = filterCurrentBlockableStatePerService(BlockingStateType.ACCOUNT);
+        blockingAggregator = blockingChecker.getBlockedStatus(currentAccountBlockingStatesForServices,
+                                                              currentBundleBlockingStatesForServices,
+                                                              currentSubscriptionBlockingStatesForServices,
                                                               internalTenantContext);
     }
 
-    private List<BlockingState> filterCurrentBlockableStatePerService(final Iterable<BlockingState> allBlockingStates) {
+    private List<BlockingState> filterCurrentBlockableStatePerService(final BlockingStateType type) {
         final Map<String, BlockingState> currentBlockingStatePerService = new HashMap<String, BlockingState>();
-        for (final BlockingState blockingState : allBlockingStates) {
+        for (final BlockingState blockingState : blockingStates) {
+            if (blockingState.getType() != type) {
+                continue;
+            }
             if (blockingState.getEffectiveDate().isAfter(utcNow)) {
                 continue;
             }
@@ -401,29 +387,6 @@ public class DefaultEventsStream implements EventsStream {
         return ImmutableList.<BlockingState>copyOf(currentBlockingStatePerService.values());
     }
 
-    private void computeEntitlementEffectiveEndDate() {
-        LocalDate result = null;
-        BlockingState lastEntry;
-
-        lastEntry = (!subscriptionEntitlementStates.isEmpty()) ? subscriptionEntitlementStates.get(subscriptionEntitlementStates.size() - 1) : null;
-        if (lastEntry != null && DefaultEntitlementApi.ENT_STATE_CANCELLED.equals(lastEntry.getStateName())) {
-            result = new LocalDate(lastEntry.getEffectiveDate(), account.getTimeZone());
-        }
-
-        lastEntry = (!bundleEntitlementStates.isEmpty()) ? bundleEntitlementStates.get(bundleEntitlementStates.size() - 1) : null;
-        if (lastEntry != null && DefaultEntitlementApi.ENT_STATE_CANCELLED.equals(lastEntry.getStateName())) {
-            final LocalDate localDate = new LocalDate(lastEntry.getEffectiveDate(), account.getTimeZone());
-            result = ((result == null) || (localDate.compareTo(result) < 0)) ? localDate : result;
-        }
-
-        lastEntry = (!accountEntitlementStates.isEmpty()) ? accountEntitlementStates.get(accountEntitlementStates.size() - 1) : null;
-        if (lastEntry != null && DefaultEntitlementApi.ENT_STATE_CANCELLED.equals(lastEntry.getStateName())) {
-            final LocalDate localDate = new LocalDate(lastEntry.getEffectiveDate(), account.getTimeZone());
-            result = ((result == null) || (localDate.compareTo(result) < 0)) ? localDate : result;
-        }
-
-        entitlementEffectiveEndDate = result;
-    }
 
     private void computeEntitlementCancelEvent() {
         entitlementCancelEvent = Iterables.<BlockingState>tryFind(subscriptionEntitlementStates,
@@ -433,6 +396,7 @@ public class DefaultEventsStream implements EventsStream {
                                                                           return DefaultEntitlementApi.ENT_STATE_CANCELLED.equals(input.getStateName());
                                                                       }
                                                                   }).orNull();
+        entitlementEffectiveEndDate = entitlementCancelEvent != null ?  new LocalDate(entitlementCancelEvent.getEffectiveDate(), account.getTimeZone()) : null;
     }
 
     private void computeStateForEntitlement() {
@@ -446,17 +410,16 @@ public class DefaultEventsStream implements EventsStream {
     }
 
     private void computeEntitlementBlockingStates() {
-        subscriptionEntitlementStates = filterBlockingStatesForTypeAndId(BlockingStateType.SUBSCRIPTION, subscription.getId());
-        bundleEntitlementStates = filterBlockingStatesForTypeAndId(BlockingStateType.SUBSCRIPTION_BUNDLE, subscription.getBundleId());
-        accountEntitlementStates = filterBlockingStatesForTypeAndId(BlockingStateType.ACCOUNT, account.getId());
+        subscriptionEntitlementStates = filterBlockingStatesForEntitlementService(BlockingStateType.SUBSCRIPTION, subscription.getId());
     }
 
-    private List<BlockingState> filterBlockingStatesForTypeAndId(final BlockingStateType blockingStateType, @Nullable final UUID blockableId) {
+    private List<BlockingState> filterBlockingStatesForEntitlementService(final BlockingStateType blockingStateType, @Nullable final UUID blockableId) {
         return ImmutableList.<BlockingState>copyOf(Iterables.<BlockingState>filter(blockingStates,
                                                                                    new Predicate<BlockingState>() {
                                                                                        @Override
                                                                                        public boolean apply(final BlockingState input) {
                                                                                            return blockingStateType.equals(input.getType()) &&
+                                                                                                  EntitlementService.ENTITLEMENT_SERVICE_NAME.equals(input.getService()) &&
                                                                                                   input.getBlockedId().equals(blockableId);
                                                                                        }
                                                                                    }));