killbill-uncached

diff --git a/account/src/main/java/com/ning/billing/account/api/svcs/DefaultAccountInternalApi.java b/account/src/main/java/com/ning/billing/account/api/svcs/DefaultAccountInternalApi.java
index 24f2cbe..e5acd59 100644
--- a/account/src/main/java/com/ning/billing/account/api/svcs/DefaultAccountInternalApi.java
+++ b/account/src/main/java/com/ning/billing/account/api/svcs/DefaultAccountInternalApi.java
@@ -62,8 +62,13 @@ public class DefaultAccountInternalApi implements AccountInternalApi {
 
     @Override
     public Account getAccountByRecordId(final Long recordId, final InternalTenantContext context) throws AccountApiException {
+        try {
         final AccountModelDao account = accountDao.getByRecordId(recordId, context);
         return new DefaultAccount(account);
+        } catch (NullPointerException e) {
+            e.printStackTrace();;
+            return null;
+        }
     }
 
     @Override

diff --git a/account/src/main/java/com/ning/billing/account/dao/DefaultAccountDao.java b/account/src/main/java/com/ning/billing/account/dao/DefaultAccountDao.java
index fc199b8..dc3fe91 100644
--- a/account/src/main/java/com/ning/billing/account/dao/DefaultAccountDao.java
+++ b/account/src/main/java/com/ning/billing/account/dao/DefaultAccountDao.java
@@ -75,7 +75,7 @@ public class DefaultAccountDao extends EntityDaoBase<AccountModelDao, Account, A
                 return;
         }
 
-        final Long recordId = getRecordId(savedAccount.getId(), context);
+        final Long recordId = entitySqlDaoWrapperFactory.become(AccountSqlDao.class).getRecordId(savedAccount.getId().toString(), context);
         // We need to re-hydrate the context with the account record id
         final InternalCallContext rehydratedContext = internalCallContextFactory.createInternalCallContext(recordId, context);
         final AccountCreationInternalEvent creationEvent = new DefaultAccountCreationEvent(savedAccount,

diff --git a/api/src/main/java/com/ning/billing/junction/api/BlockingState.java b/api/src/main/java/com/ning/billing/junction/api/BlockingState.java
index a324506..d46e799 100644
--- a/api/src/main/java/com/ning/billing/junction/api/BlockingState.java
+++ b/api/src/main/java/com/ning/billing/junction/api/BlockingState.java
@@ -16,6 +16,8 @@
 
 package com.ning.billing.junction.api;
 
+import java.util.UUID;
+
 import org.joda.time.DateTime;
 
 import com.ning.billing.util.entity.Entity;
@@ -23,23 +25,27 @@ import com.ning.billing.util.entity.Entity;
 
 public interface BlockingState extends Entity, Comparable<BlockingState> {
 
-    public abstract String getStateName();
+    public UUID getBlockedId();
+
+    public String getStateName();
+
+    public Blockable.Type getType();
 
-    public abstract Blockable.Type getType();
+    public DateTime getTimestamp();
 
-    public abstract DateTime getTimestamp();
+    public boolean isBlockChange();
 
-    public abstract boolean isBlockChange();
+    public boolean isBlockEntitlement();
 
-    public abstract boolean isBlockEntitlement();
+    public boolean isBlockBilling();
 
-    public abstract boolean isBlockBilling();
+    public int compareTo(BlockingState arg0);
 
-    public abstract int compareTo(BlockingState arg0);
+    public int hashCode();
 
-    public abstract int hashCode();
+    public String getDescription();
 
-    public abstract String getDescription();
+    public String toString();
 
-    public abstract String toString();
+    public String getService();
 }

diff --git a/beatrix/src/test/java/com/ning/billing/beatrix/integration/TestIntegration.java b/beatrix/src/test/java/com/ning/billing/beatrix/integration/TestIntegration.java
index 8f21dfa..dfd9176 100644
--- a/beatrix/src/test/java/com/ning/billing/beatrix/integration/TestIntegration.java
+++ b/beatrix/src/test/java/com/ning/billing/beatrix/integration/TestIntegration.java
@@ -266,6 +266,8 @@ public class TestIntegration extends TestIntegrationBase {
         // CREATE SUBSCRIPTION AND EXPECT BOTH EVENTS: NextEvent.CREATE NextEvent.INVOICE
         //
         SubscriptionData subscription = subscriptionDataFromSubscription(createSubscriptionAndCheckForCompletion(bundle.getId(), "Shotgun", ProductCategory.BASE, BillingPeriod.MONTHLY, NextEvent.CREATE, NextEvent.INVOICE));
+
+
         invoiceChecker.checkInvoice(account.getId(), invoiceItemCount++, callContext, new ExpectedItemCheck(initialCreationDate.toLocalDate(), null, InvoiceItemType.FIXED, new BigDecimal("0")));
         // No end date for the trial item (fixed price of zero), and CTD should be today (i.e. when the trial started)
         invoiceChecker.checkChargedThroughDate(subscription.getId(), clock.getUTCToday(), callContext);

diff --git a/invoice/src/main/java/com/ning/billing/invoice/dao/DefaultInvoiceDao.java b/invoice/src/main/java/com/ning/billing/invoice/dao/DefaultInvoiceDao.java
index 0570fc2..730fbbc 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/dao/DefaultInvoiceDao.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/dao/DefaultInvoiceDao.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2011 Ning, Inc.
+ * Copyright 2010-2012 Ning, Inc.
  *
  * Ning licenses this file to you under the Apache License, version 2.0
  * (the "License"); you may not use this file except in compliance with the
@@ -185,7 +185,7 @@ public class DefaultInvoiceDao extends EntityDaoBase<InvoiceModelDao, Invoice, I
                     final List<InvoiceItemModelDao> recurringInvoiceItems = ImmutableList.<InvoiceItemModelDao>copyOf(Collections2.filter(invoiceItems, new Predicate<InvoiceItemModelDao>() {
                         @Override
                         public boolean apply(@Nullable final InvoiceItemModelDao item) {
-                            return RecurringInvoiceItem.class.isInstance(item);
+                            return item.getType() == InvoiceItemType.RECURRING;
                         }
                     }));
                     notifyOfFutureBillingEvents(entitySqlDaoWrapperFactory, invoice.getAccountId(), recurringInvoiceItems);

diff --git a/junction/src/main/java/com/ning/billing/junction/api/svcs/DefaultInternalBlockingApi.java b/junction/src/main/java/com/ning/billing/junction/api/svcs/DefaultInternalBlockingApi.java
index 554a5eb..48a4988 100644
--- a/junction/src/main/java/com/ning/billing/junction/api/svcs/DefaultInternalBlockingApi.java
+++ b/junction/src/main/java/com/ning/billing/junction/api/svcs/DefaultInternalBlockingApi.java
@@ -43,7 +43,7 @@ public class DefaultInternalBlockingApi implements BlockingInternalApi {
 
     @Override
     public BlockingState getBlockingStateFor(final Blockable overdueable, final InternalTenantContext context) {
-        BlockingState state = dao.getBlockingStateFor(overdueable, context);
+        BlockingState state = dao.getBlockingStateFor(overdueable.getId(), context);
         if (state == null) {
             state = DefaultBlockingState.getClearState();
         }
@@ -57,7 +57,7 @@ public class DefaultInternalBlockingApi implements BlockingInternalApi {
 
     @Override
     public List<BlockingState> getBlockingHistory(final Blockable overdueable, final InternalTenantContext context) {
-        return dao.getBlockingHistoryFor(overdueable, context);
+        return dao.getBlockingHistoryFor(overdueable.getId(), context);
     }
 
     @Override

diff --git a/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateDao.java b/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateDao.java
index f33d3d4..8266091 100644
--- a/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateDao.java
+++ b/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateDao.java
@@ -27,16 +27,9 @@ import com.ning.billing.util.clock.Clock;
 
 public interface BlockingStateDao {
 
-    // Read
-    public BlockingState getBlockingStateFor(Blockable blockable, InternalTenantContext context);
-
     public BlockingState getBlockingStateFor(UUID blockableId, InternalTenantContext context);
 
-    public List<BlockingState> getBlockingHistoryFor(Blockable blockable, InternalTenantContext context);
-
     public List<BlockingState> getBlockingHistoryFor(UUID blockableId, InternalTenantContext context);
 
-    // Write
     <T extends Blockable> void setBlockingState(BlockingState state, Clock clock, InternalCallContext context);
-
-} 
+}

diff --git a/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateModelDao.java b/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateModelDao.java
new file mode 100644
index 0000000..5dbdd25
--- /dev/null
+++ b/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateModelDao.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2010-2012 Ning, Inc.
+ *
+ * Ning licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package com.ning.billing.junction.dao;
+
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+
+import com.ning.billing.junction.api.Blockable;
+import com.ning.billing.junction.api.Blockable.Type;
+import com.ning.billing.junction.api.BlockingState;
+import com.ning.billing.util.callcontext.InternalCallContext;
+import com.ning.billing.util.dao.TableName;
+import com.ning.billing.util.entity.EntityBase;
+import com.ning.billing.util.entity.dao.EntityModelDao;
+import com.ning.billing.util.svcapi.junction.DefaultBlockingState;
+
+public class BlockingStateModelDao extends EntityBase implements EntityModelDao<BlockingState>{
+
+    private final UUID blockableId;
+    private final Type type;
+    private final String state;
+    private final String service;
+    private final Boolean blockChange;
+    private final Boolean blockEntitlement;
+    private final Boolean blockBilling;
+
+    public BlockingStateModelDao(final UUID id, final UUID blockableId, final Type type, final String state, final String service, final Boolean blockChange, final Boolean blockEntitlement,
+                                 final Boolean blockBilling, final DateTime createDate, final DateTime updateDate) {
+        super(id, createDate, updateDate);
+        this.blockableId = blockableId;
+        this.type = type;
+        this.state = state;
+        this.service = service;
+        this.blockChange = blockChange;
+        this.blockEntitlement = blockEntitlement;
+        this.blockBilling = blockBilling;
+    }
+
+    public BlockingStateModelDao(final BlockingState src, InternalCallContext context) {
+        this(src.getId(), src.getBlockedId(), src.getType(), src.getStateName(), src.getService(), src.isBlockChange(),
+             src.isBlockEntitlement(), src.isBlockBilling(), context.getCreatedDate(), context.getUpdatedDate());
+    }
+
+    public UUID getBlockableId() {
+        return blockableId;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public String getState() {
+        return state;
+    }
+
+    public String getService() {
+        return service;
+    }
+
+    public Boolean getBlockChange() {
+        return blockChange;
+    }
+
+    public Boolean getBlockEntitlement() {
+        return blockEntitlement;
+    }
+
+    public Boolean getBlockBilling() {
+        return blockBilling;
+    }
+
+    public static BlockingState toBlockingState(BlockingStateModelDao src) {
+        if (src == null) {
+            return null;
+        }
+        return new DefaultBlockingState(src.getId(), src.getBlockableId(),src.getState(), src.getType(), src.getService(), src.getBlockChange(), src.getBlockEntitlement(), src.getBlockBilling(),
+                                 src.getCreatedDate(), src.getUpdatedDate());
+    }
+
+    @Override
+    public TableName getTableName() {
+        return TableName.BLOCKING_STATES;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        sb.append("BlockingStateModelDao");
+        sb.append("{blockableId=").append(blockableId);
+        sb.append(", type=").append(type);
+        sb.append(", state='").append(state).append('\'');
+        sb.append(", service='").append(service).append('\'');
+        sb.append(", blockChange=").append(blockChange);
+        sb.append(", blockEntitlement=").append(blockEntitlement);
+        sb.append(", blockBilling=").append(blockBilling);
+        sb.append('}');
+        return sb.toString();
+    }
+}

diff --git a/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateSqlDao.java b/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateSqlDao.java
index 9e33d3d..c1edb7e 100644
--- a/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateSqlDao.java
+++ b/junction/src/main/java/com/ning/billing/junction/dao/BlockingStateSqlDao.java
@@ -25,10 +25,12 @@ import org.joda.time.DateTime;
 import org.skife.jdbi.v2.SQLStatement;
 import org.skife.jdbi.v2.StatementContext;
 import org.skife.jdbi.v2.sqlobject.Bind;
+import org.skife.jdbi.v2.sqlobject.BindBean;
 import org.skife.jdbi.v2.sqlobject.Binder;
 import org.skife.jdbi.v2.sqlobject.SqlQuery;
 import org.skife.jdbi.v2.sqlobject.SqlUpdate;
 import org.skife.jdbi.v2.sqlobject.customizers.Mapper;
+import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper;
 import org.skife.jdbi.v2.sqlobject.mixins.CloseMe;
 import org.skife.jdbi.v2.sqlobject.mixins.Transmogrifier;
 import org.skife.jdbi.v2.sqlobject.stringtemplate.ExternalizedSqlViaStringTemplate3;
@@ -45,45 +47,25 @@ import com.ning.billing.util.callcontext.InternalTenantContextBinder;
 import com.ning.billing.util.clock.Clock;
 import com.ning.billing.util.dao.BinderBase;
 import com.ning.billing.util.dao.MapperBase;
+import com.ning.billing.util.entity.dao.EntitySqlDao;
+import com.ning.billing.util.entity.dao.EntitySqlDaoStringTemplate;
 import com.ning.billing.util.svcapi.junction.DefaultBlockingState;
 
-@ExternalizedSqlViaStringTemplate3()
-public interface BlockingStateSqlDao extends BlockingStateDao, CloseMe, Transmogrifier {
+@EntitySqlDaoStringTemplate
+@RegisterMapper(BlockingStateSqlDao.BlockingHistorySqlMapper.class)
+public interface BlockingStateSqlDao extends EntitySqlDao<BlockingStateModelDao, BlockingState> {
 
-    @Override
-    @SqlUpdate
-    public abstract <T extends Blockable> void setBlockingState(@Bind(binder = BlockingStateBinder.class) BlockingState state,
-                                                                @Bind(binder = CurrentTimeBinder.class) Clock clock,
-                                                                @InternalTenantContextBinder final InternalCallContext context);
-
-    @Override
-    @SqlQuery
-    @Mapper(BlockingHistorySqlMapper.class)
-    public abstract BlockingState getBlockingStateFor(@Bind(binder = BlockableBinder.class) Blockable overdueable,
-                                                      @InternalTenantContextBinder final InternalTenantContext context);
-
-    @Override
     @SqlQuery
-    @Mapper(BlockingHistorySqlMapper.class)
-    public abstract BlockingState getBlockingStateFor(@Bind(binder = UUIDBinder.class) UUID overdueableId,
-                                                      @InternalTenantContextBinder final InternalTenantContext context);
+    public BlockingStateModelDao getBlockingStateFor(@Bind("blockableId") UUID blockableId, @BindBean final InternalTenantContext context);
 
-    @Override
     @SqlQuery
-    @Mapper(BlockingHistorySqlMapper.class)
-    public abstract List<BlockingState> getBlockingHistoryFor(@Bind(binder = BlockableBinder.class) Blockable blockable,
-                                                              @InternalTenantContextBinder final InternalTenantContext context);
+    public abstract List<BlockingStateModelDao> getBlockingHistoryFor(@Bind("blockableId") UUID blockableId,
+                                                              @BindBean final InternalTenantContext context);
 
-    @Override
-    @SqlQuery
-    @Mapper(BlockingHistorySqlMapper.class)
-    public abstract List<BlockingState> getBlockingHistoryFor(@Bind(binder = UUIDBinder.class) UUID blockableId,
-                                                              @InternalTenantContextBinder final InternalTenantContext context);
-
-    public class BlockingHistorySqlMapper extends MapperBase implements ResultSetMapper<BlockingState> {
+    public class BlockingHistorySqlMapper extends MapperBase implements ResultSetMapper<BlockingStateModelDao> {
 
         @Override
-        public BlockingState map(final int index, final ResultSet r, final StatementContext ctx)
+        public BlockingStateModelDao map(final int index, final ResultSet r, final StatementContext ctx)
                 throws SQLException {
 
             final UUID id;
@@ -112,74 +94,7 @@ public interface BlockingStateSqlDao extends BlockingStateDao, CloseMe, Transmog
             } catch (BlockingApiException e) {
                 throw new SQLException(e);
             }
-            return new DefaultBlockingState(id, blockableId, stateName, type, service, blockChange, blockEntitlement, blockBilling, timestamp, createdDate);
-        }
-    }
-
-    public static class BlockingStateSqlMapper extends MapperBase implements ResultSetMapper<String> {
-
-        @Override
-        public String map(final int index, final ResultSet r, final StatementContext ctx)
-                throws SQLException {
-            return r.getString("state") == null ? DefaultBlockingState.CLEAR_STATE_NAME : r.getString("state");
-        }
-    }
-
-    public static class BlockingStateBinder extends BinderBase implements Binder<Bind, DefaultBlockingState> {
-
-        @Override
-        public void bind(@SuppressWarnings("rawtypes") final SQLStatement stmt, final Bind bind, final DefaultBlockingState state) {
-            stmt.bind("id", state.getId().toString());
-            stmt.bind("blockableId", state.getBlockedId().toString());
-            stmt.bind("state", state.getStateName().toString());
-            stmt.bind("type", state.getType().toString());
-            stmt.bind("service", state.getService().toString());
-            stmt.bind("blockChange", state.isBlockChange());
-            stmt.bind("blockEntitlement", state.isBlockEntitlement());
-            stmt.bind("blockBilling", state.isBlockBilling());
-        }
-    }
-
-    public static class UUIDBinder extends BinderBase implements Binder<Bind, UUID> {
-
-        @Override
-        public void bind(@SuppressWarnings("rawtypes") final SQLStatement stmt, final Bind bind, final UUID id) {
-            stmt.bind("blockable_id", id.toString());
-        }
-    }
-
-    public static class BlockableBinder extends BinderBase implements Binder<Bind, Blockable> {
-
-        @Override
-        public void bind(@SuppressWarnings("rawtypes") final SQLStatement stmt, final Bind bind, final Blockable overdueable) {
-            stmt.bind("blockable_id", overdueable.getId().toString());
-        }
-    }
-
-    public static class OverdueStateBinder<T extends Blockable> extends BinderBase implements Binder<Bind, OverdueState<T>> {
-
-        @Override
-        public void bind(final SQLStatement<?> stmt, final Bind bind, final OverdueState<T> overdueState) {
-            stmt.bind("state", overdueState.getName());
-        }
-    }
-
-    public class BlockableTypeBinder extends BinderBase implements Binder<Bind, Blockable.Type> {
-
-        @Override
-        public void bind(@SuppressWarnings("rawtypes") final SQLStatement stmt, final Bind bind, final Type type) {
-            stmt.bind("type", type.name());
+            return new BlockingStateModelDao(id, blockableId, type, stateName, service, blockChange,blockEntitlement, blockBilling, createdDate, createdDate);
         }
-
     }
-
-    public static class CurrentTimeBinder extends BinderBase implements Binder<Bind, Clock> {
-
-        @Override
-        public void bind(@SuppressWarnings("rawtypes") final SQLStatement stmt, final Bind bind, final Clock clock) {
-            stmt.bind("created_date", clock.getUTCNow().toDate());
-        }
-
-    }
-
 }

diff --git a/junction/src/main/java/com/ning/billing/junction/dao/DefaultBlockingStateDao.java b/junction/src/main/java/com/ning/billing/junction/dao/DefaultBlockingStateDao.java
new file mode 100644
index 0000000..ec1945e
--- /dev/null
+++ b/junction/src/main/java/com/ning/billing/junction/dao/DefaultBlockingStateDao.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2010-2012 Ning, Inc.
+ *
+ * Ning licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package com.ning.billing.junction.dao;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+
+import org.skife.jdbi.v2.IDBI;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.ning.billing.junction.api.Blockable;
+import com.ning.billing.junction.api.BlockingState;
+import com.ning.billing.util.callcontext.InternalCallContext;
+import com.ning.billing.util.callcontext.InternalTenantContext;
+import com.ning.billing.util.clock.Clock;
+import com.ning.billing.util.entity.dao.EntitySqlDao;
+import com.ning.billing.util.entity.dao.EntitySqlDaoTransactionWrapper;
+import com.ning.billing.util.entity.dao.EntitySqlDaoTransactionalJdbiWrapper;
+import com.ning.billing.util.entity.dao.EntitySqlDaoWrapperFactory;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Collections2;
+
+public class DefaultBlockingStateDao implements BlockingStateDao {
+
+
+    private static final Logger log = LoggerFactory.getLogger(DefaultBlockingStateDao.class);
+
+    private final Clock clock;
+    private final EntitySqlDaoTransactionalJdbiWrapper transactionalSqlDao;
+
+    @Inject
+    public DefaultBlockingStateDao(final IDBI dbi, final Clock clock) {
+        this.clock = clock;
+        this.transactionalSqlDao = new EntitySqlDaoTransactionalJdbiWrapper(dbi);
+    }
+
+
+    @Override
+    public BlockingState getBlockingStateFor(final UUID blockableId, final InternalTenantContext context) {
+        return transactionalSqlDao.execute(new EntitySqlDaoTransactionWrapper<BlockingState>() {
+            @Override
+            public BlockingState inTransaction(final EntitySqlDaoWrapperFactory<EntitySqlDao> entitySqlDaoWrapperFactory) throws Exception {
+                final BlockingStateModelDao model =  entitySqlDaoWrapperFactory.become(BlockingStateSqlDao.class).getBlockingStateFor(blockableId, context);
+                return BlockingStateModelDao.toBlockingState(model);
+
+            }
+        });
+    }
+
+
+
+    @Override
+    public List<BlockingState> getBlockingHistoryFor(final UUID blockableId, final InternalTenantContext context) {
+        return transactionalSqlDao.execute(new EntitySqlDaoTransactionWrapper<List<BlockingState>>() {
+            @Override
+            public List<BlockingState> inTransaction(final EntitySqlDaoWrapperFactory<EntitySqlDao> entitySqlDaoWrapperFactory) throws Exception {
+                List<BlockingStateModelDao> models = entitySqlDaoWrapperFactory.become(BlockingStateSqlDao.class).getBlockingHistoryFor(blockableId, context);
+                return new ArrayList<BlockingState>(Collections2.transform(models, new Function<BlockingStateModelDao, BlockingState>() {
+                    @Override
+                    public BlockingState apply(@Nullable final BlockingStateModelDao src) {
+                        return BlockingStateModelDao.toBlockingState(src);
+                    }
+                }));
+            }
+        });
+    }
+
+    @Override
+    public <T extends Blockable> void setBlockingState(final BlockingState state, final Clock clock, final InternalCallContext context) {
+        transactionalSqlDao.execute(new EntitySqlDaoTransactionWrapper<Void>() {
+            @Override
+            public Void inTransaction(final EntitySqlDaoWrapperFactory<EntitySqlDao> entitySqlDaoWrapperFactory) throws Exception {
+                final BlockingStateSqlDao sqlDao = entitySqlDaoWrapperFactory.become(BlockingStateSqlDao.class);
+                sqlDao.create(new BlockingStateModelDao(state, context), context);
+                return null;
+            }
+        });
+    }
+}

diff --git a/junction/src/main/java/com/ning/billing/junction/glue/DefaultJunctionModule.java b/junction/src/main/java/com/ning/billing/junction/glue/DefaultJunctionModule.java
index e7b37bd..756b50c 100644
--- a/junction/src/main/java/com/ning/billing/junction/glue/DefaultJunctionModule.java
+++ b/junction/src/main/java/com/ning/billing/junction/glue/DefaultJunctionModule.java
@@ -26,12 +26,14 @@ import com.ning.billing.junction.block.BlockingChecker;
 import com.ning.billing.junction.block.DefaultBlockingChecker;
 import com.ning.billing.junction.dao.BlockingStateDao;
 import com.ning.billing.junction.dao.BlockingStateSqlDao;
+import com.ning.billing.junction.dao.DefaultBlockingStateDao;
 import com.ning.billing.junction.plumbing.api.BlockingAccountUserApi;
 import com.ning.billing.junction.plumbing.api.BlockingEntitlementUserApi;
 import com.ning.billing.junction.plumbing.billing.BlockingCalculator;
 import com.ning.billing.junction.plumbing.billing.DefaultInternalBillingApi;
 import com.ning.billing.util.svcapi.junction.BillingInternalApi;
 import com.ning.billing.util.svcapi.junction.BlockingInternalApi;
+import com.ning.billing.util.svcapi.junction.DefaultBlockingState;
 
 import com.google.inject.AbstractModule;
 import com.google.inject.Inject;
@@ -63,7 +65,7 @@ public class DefaultJunctionModule extends AbstractModule implements JunctionMod
     }
 
     public void installBlockingStateDao() {
-        bind(BlockingStateDao.class).toProvider(BlockingDaoProvider.class);
+        bind(BlockingStateDao.class).to(DefaultBlockingStateDao.class).asEagerSingleton();
     }
 
     public void installAccountUserApi() {
@@ -81,19 +83,4 @@ public class DefaultJunctionModule extends AbstractModule implements JunctionMod
     public void installBlockingCalculator() {
         bind(BlockingCalculator.class).asEagerSingleton();
     }
-
-    public static class BlockingDaoProvider implements Provider<BlockingStateDao> {
-        private final IDBI dbi;
-
-
-        @Inject
-        public BlockingDaoProvider(final IDBI dbi) {
-            this.dbi = dbi;
-        }
-
-        @Override
-        public BlockingStateDao get() {
-            return dbi.onDemand(BlockingStateSqlDao.class);
-        }
-    }
 }

diff --git a/junction/src/main/resources/com/ning/billing/junction/dao/BlockingStateSqlDao.sql.stg b/junction/src/main/resources/com/ning/billing/junction/dao/BlockingStateSqlDao.sql.stg
index 0cfcd63..d477691 100644
--- a/junction/src/main/resources/com/ning/billing/junction/dao/BlockingStateSqlDao.sql.stg
+++ b/junction/src/main/resources/com/ning/billing/junction/dao/BlockingStateSqlDao.sql.stg
@@ -1,11 +1,12 @@
 group BlockingStateSqlDao: EntitySqlDao;
 
 
+tableName() ::= "blocking_states"
+
 tableFields(prefix) ::= <<
- <prefix>id
-, <prefix>blockable_id
-, <prefix>state
+  <prefix>blockable_id
 , <prefix>type
+, <prefix>state
 , <prefix>service
 , <prefix>block_change
 , <prefix>block_entitlement
@@ -15,10 +16,9 @@ tableFields(prefix) ::= <<
 
 
 tableValues() ::= <<
- :id
-, :blockableId
-, :state
+  :blockableId
 , :type
+, :state
 , :service
 , :blockChange
 , :blockEntitlement
@@ -27,42 +27,26 @@ tableValues() ::= <<
 >>
 
 getBlockingStateFor() ::= <<
-    select
-        id
-      , blockable_id
-      , state
-      , type
-      , service
-      , block_change
-      , block_entitlement
-      , block_billing
-      , created_date
-      , tenant_record_id
-    from blocking_states
-    where blockable_id = :blockable_id
-    <AND_CHECK_TENANT()>
-    -- We want the current state, hence the order desc and limit 1
-    order by created_date desc, record_id desc
-    limit 1
-    ;
+select
+<allTableFields()>
+from
+<tableName()>
+where blockable_id = :blockableId
+<AND_CHECK_TENANT()>
+-- We want the current state, hence the order desc and limit 1
+order by created_date desc, record_id desc
+limit 1
+;
 >>
 
 getBlockingHistoryFor() ::= <<
-    select
-       id
-      , blockable_id
-      , state
-      , type
-      , service
-      , block_change
-      , block_entitlement
-      , block_billing
-      , created_date
-      , tenant_record_id
-    from blocking_states
-    where blockable_id = :blockable_id
-    <AND_CHECK_TENANT()>
-    -- We want the history in order
-    order by created_date asc, record_id asc
-    ;
+select
+<allTableFields()>
+from
+<tableName()>
+where blockable_id = :blockableId
+<AND_CHECK_TENANT()>
+-- We want the current state, hence the order desc and limit 1
+order by created_date asc, record_id asc
+;
 >>

diff --git a/junction/src/test/java/com/ning/billing/junction/api/blocking/TestDefaultBlockingApi.java b/junction/src/test/java/com/ning/billing/junction/api/blocking/TestDefaultBlockingApi.java
index 5d1c7a2..13f84ba 100644
--- a/junction/src/test/java/com/ning/billing/junction/api/blocking/TestDefaultBlockingApi.java
+++ b/junction/src/test/java/com/ning/billing/junction/api/blocking/TestDefaultBlockingApi.java
@@ -32,6 +32,7 @@ import com.ning.billing.junction.api.svcs.DefaultInternalBlockingApi;
 import com.ning.billing.junction.api.BlockingState;
 import com.ning.billing.junction.dao.BlockingStateDao;
 import com.ning.billing.junction.dao.BlockingStateSqlDao;
+import com.ning.billing.junction.dao.DefaultBlockingStateDao;
 import com.ning.billing.util.clock.ClockMock;
 import com.ning.billing.util.svcapi.junction.DefaultBlockingState;
 
@@ -43,11 +44,10 @@ public class TestDefaultBlockingApi extends JunctionTestSuiteWithEmbeddedDB {
 
     @BeforeMethod(groups = "slow")
     public void setUp() throws Exception {
-        final BlockingStateDao blockingStateDao = getMysqlTestingHelper().getDBI().onDemand(BlockingStateSqlDao.class);
+        final BlockingStateDao blockingStateDao = new DefaultBlockingStateDao(getMysqlTestingHelper().getDBI(), clock);
         blockingApi = new DefaultInternalBlockingApi(blockingStateDao, clock);
     }
 
-    // API_FIX
     @Test(groups = "slow", enabled=false)
     public void testSetBlockingStateOnBundle() throws Exception {
         final UUID bundleId = UUID.randomUUID();

diff --git a/junction/src/test/java/com/ning/billing/junction/blocking/TestBlockingChecker.java b/junction/src/test/java/com/ning/billing/junction/blocking/TestBlockingChecker.java
index 7607964..1b3d1ba 100644
--- a/junction/src/test/java/com/ning/billing/junction/blocking/TestBlockingChecker.java
+++ b/junction/src/test/java/com/ning/billing/junction/blocking/TestBlockingChecker.java
@@ -53,16 +53,7 @@ public class TestBlockingChecker extends JunctionTestSuite {
     private BlockingState accountState;
 
     private final BlockingStateDao dao = new BlockingStateDao() {
-        @Override
-        public BlockingState getBlockingStateFor(final Blockable blockable, final InternalTenantContext context) {
-            if (blockable.getId() == account.getId()) {
-                return accountState;
-            } else if (blockable.getId() == subscription.getId()) {
-                return subscriptionState;
-            } else {
-                return bundleState;
-            }
-        }
+
 
         @Override
         public BlockingState getBlockingStateFor(final UUID blockableId, final InternalTenantContext context) {
@@ -75,10 +66,6 @@ public class TestBlockingChecker extends JunctionTestSuite {
             }
         }
 
-        @Override
-        public List<BlockingState> getBlockingHistoryFor(final Blockable overdueable, final InternalTenantContext context) {
-            throw new UnsupportedOperationException();
-        }
 
         @Override
         public List<BlockingState> getBlockingHistoryFor(final UUID overdueableId, final InternalTenantContext context) {

diff --git a/junction/src/test/java/com/ning/billing/junction/dao/TestBlockingDao.java b/junction/src/test/java/com/ning/billing/junction/dao/TestBlockingDao.java
index 2c1c4a2..5730a39 100644
--- a/junction/src/test/java/com/ning/billing/junction/dao/TestBlockingDao.java
+++ b/junction/src/test/java/com/ning/billing/junction/dao/TestBlockingDao.java
@@ -43,8 +43,6 @@ public class TestBlockingDao extends JunctionTestSuiteWithEmbeddedDB {
     @Inject
     private BlockingStateDao dao;
 
-    private final InternalTenantContext tenantContext = Mockito.mock(InternalTenantContext.class);
-    private final InternalCallContext context = Mockito.mock(InternalCallContext.class);
 
     @Test(groups = "slow")
     public void testDao() {
@@ -58,18 +56,17 @@ public class TestBlockingDao extends JunctionTestSuiteWithEmbeddedDB {
         final boolean blockBilling = false;
 
         final BlockingState state1 = new DefaultBlockingState(uuid, overdueStateName, Blockable.Type.SUBSCRIPTION_BUNDLE, service, blockChange, blockEntitlement, blockBilling);
-        dao.setBlockingState(state1, clock, context);
+        dao.setBlockingState(state1, clock, internalCallContext);
         clock.setDeltaFromReality(1000 * 3600 * 24);
 
         final String overdueStateName2 = "NoReallyThisCantGoOn";
         final BlockingState state2 = new DefaultBlockingState(uuid, overdueStateName2, Blockable.Type.SUBSCRIPTION_BUNDLE, service, blockChange, blockEntitlement, blockBilling);
-        dao.setBlockingState(state2, clock, context);
+        dao.setBlockingState(state2, clock, internalCallContext);
 
         final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
         Mockito.when(bundle.getId()).thenReturn(uuid);
 
-        Assert.assertEquals(dao.getBlockingStateFor(bundle, tenantContext).getStateName(), state2.getStateName());
-        Assert.assertEquals(dao.getBlockingStateFor(bundle.getId(), tenantContext).getStateName(), overdueStateName2);
+        Assert.assertEquals(dao.getBlockingStateFor(uuid, internalCallContext).getStateName(), state2.getStateName());
     }
 
     @Test(groups = "slow")
@@ -84,23 +81,18 @@ public class TestBlockingDao extends JunctionTestSuiteWithEmbeddedDB {
         final boolean blockBilling = false;
 
         final BlockingState state1 = new DefaultBlockingState(uuid, overdueStateName, Blockable.Type.SUBSCRIPTION_BUNDLE, service, blockChange, blockEntitlement, blockBilling);
-        dao.setBlockingState(state1, clock, context);
+        dao.setBlockingState(state1, clock, internalCallContext);
         clock.setDeltaFromReality(1000 * 3600 * 24);
 
         final String overdueStateName2 = "NoReallyThisCantGoOn";
         final BlockingState state2 = new DefaultBlockingState(uuid, overdueStateName2, Blockable.Type.SUBSCRIPTION_BUNDLE, service, blockChange, blockEntitlement, blockBilling);
-        dao.setBlockingState(state2, clock, context);
+        dao.setBlockingState(state2, clock, internalCallContext);
 
         final SubscriptionBundle bundle = Mockito.mock(SubscriptionBundle.class);
         Mockito.when(bundle.getId()).thenReturn(uuid);
 
-        final List<BlockingState> history1 = dao.getBlockingHistoryFor(bundle, tenantContext);
-        final List<BlockingState> history2 = dao.getBlockingHistoryFor(bundle.getId(), tenantContext);
-
-        Assert.assertEquals(history1.size(), 2);
-        Assert.assertEquals(history1.get(0).getStateName(), overdueStateName);
-        Assert.assertEquals(history1.get(1).getStateName(), overdueStateName2);
 
+        final List<BlockingState> history2 = dao.getBlockingHistoryFor(bundle.getId(), internalCallContext);
         Assert.assertEquals(history2.size(), 2);
         Assert.assertEquals(history2.get(0).getStateName(), overdueStateName);
         Assert.assertEquals(history2.get(1).getStateName(), overdueStateName2);

diff --git a/overdue/src/test/java/com/ning/billing/overdue/applicator/ApplicatorMockJunctionModule.java b/overdue/src/test/java/com/ning/billing/overdue/applicator/ApplicatorMockJunctionModule.java
index 35edf31..0c1ac40 100644
--- a/overdue/src/test/java/com/ning/billing/overdue/applicator/ApplicatorMockJunctionModule.java
+++ b/overdue/src/test/java/com/ning/billing/overdue/applicator/ApplicatorMockJunctionModule.java
@@ -45,6 +45,11 @@ public class ApplicatorMockJunctionModule extends MockJunctionModule {
             return new BlockingState() {
 
                 @Override
+                public UUID getBlockedId() {
+                    return overdueable.getId();
+                }
+
+                @Override
                 public String getStateName() {
                     return DefaultBlockingState.CLEAR_STATE_NAME;
                 }
@@ -86,6 +91,11 @@ public class ApplicatorMockJunctionModule extends MockJunctionModule {
                 }
 
                 @Override
+                public String getService() {
+                    return "whatever";
+                }
+
+                @Override
                 public UUID getId() {
                     return UUID.randomUUID();
                 }

diff --git a/payment/src/main/resources/com/ning/billing/payment/dao/PaymentMethodSqlDao.sql.stg b/payment/src/main/resources/com/ning/billing/payment/dao/PaymentMethodSqlDao.sql.stg
index c0b0b76..e6d5794 100644
--- a/payment/src/main/resources/com/ning/billing/payment/dao/PaymentMethodSqlDao.sql.stg
+++ b/payment/src/main/resources/com/ning/billing/payment/dao/PaymentMethodSqlDao.sql.stg
@@ -57,7 +57,7 @@ where  id = :id
 getPaymentMethodIncludedDelete(accountId) ::= <<
 select <allTableFields()>
 from <tableName()>
-where account_id = :accountId
+where id = :id
 ;
 >>
 

diff --git a/util/src/main/java/com/ning/billing/util/dao/TableName.java b/util/src/main/java/com/ning/billing/util/dao/TableName.java
index 14b0693..0e4da16 100644
--- a/util/src/main/java/com/ning/billing/util/dao/TableName.java
+++ b/util/src/main/java/com/ning/billing/util/dao/TableName.java
@@ -29,6 +29,7 @@ public enum TableName {
     ACCOUNT_EMAIL_HISTORY("account_email_history"),
     ACCOUNT_EMAIL("account_emails", ObjectType.ACCOUNT_EMAIL, ACCOUNT_EMAIL_HISTORY),
     BUNDLES("bundles", ObjectType.BUNDLE),
+    BLOCKING_STATES("blocking_states"),
     CUSTOM_FIELD_HISTORY("custom_field_history"),
     CUSTOM_FIELD("custom_fields", ObjectType.CUSTOM_FIELD, CUSTOM_FIELD_HISTORY),
     INVOICE_ITEMS("invoice_items", ObjectType.INVOICE_ITEM),

diff --git a/util/src/main/java/com/ning/billing/util/entity/dao/EntityDaoBase.java b/util/src/main/java/com/ning/billing/util/entity/dao/EntityDaoBase.java
index b8e1788..cfa095e 100644
--- a/util/src/main/java/com/ning/billing/util/entity/dao/EntityDaoBase.java
+++ b/util/src/main/java/com/ning/billing/util/entity/dao/EntityDaoBase.java
@@ -48,7 +48,10 @@ public abstract class EntityDaoBase<M extends EntityModelDao<E>, E extends Entit
                 final EntitySqlDao<M, E> transactional = entitySqlDaoWrapperFactory.become(realSqlDao);
                 transactional.create(entity, context);
 
-                postBusEventFromTransaction(entity, entity, ChangeType.INSERT, entitySqlDaoWrapperFactory, context);
+
+                final M refreshedEntity = transactional.getById(entity.getId().toString(), context);
+
+                postBusEventFromTransaction(entity, refreshedEntity, ChangeType.INSERT, entitySqlDaoWrapperFactory, context);
                 return null;
             }
         });

diff --git a/util/src/main/java/com/ning/billing/util/entity/dao/EntitySqlDaoWrapperInvocationHandler.java b/util/src/main/java/com/ning/billing/util/entity/dao/EntitySqlDaoWrapperInvocationHandler.java
index 071e530..8fa62d5 100644
--- a/util/src/main/java/com/ning/billing/util/entity/dao/EntitySqlDaoWrapperInvocationHandler.java
+++ b/util/src/main/java/com/ning/billing/util/entity/dao/EntitySqlDaoWrapperInvocationHandler.java
@@ -187,8 +187,8 @@ public class EntitySqlDaoWrapperInvocationHandler<S extends EntitySqlDao<M, E>, 
     }
 
     private List<String> retrieveEntityIdsFromArguments(final Method method, final Object[] args) {
-        final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
 
+        final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
         int i = -1;
         for (final Object arg : args) {
             i++;
@@ -239,6 +239,7 @@ public class EntitySqlDaoWrapperInvocationHandler<S extends EntitySqlDao<M, E>, 
         return entityIds;
     }
 
+
     private InternalCallContext retrieveContextFromArguments(final Object[] args) {
         for (final Object arg : args) {
             if (!(arg instanceof InternalCallContext)) {
@@ -246,7 +247,6 @@ public class EntitySqlDaoWrapperInvocationHandler<S extends EntitySqlDao<M, E>, 
             }
             return (InternalCallContext) arg;
         }
-
         return null;
     }
 

diff --git a/util/src/main/java/com/ning/billing/util/svcapi/junction/DefaultBlockingState.java b/util/src/main/java/com/ning/billing/util/svcapi/junction/DefaultBlockingState.java
index d1c9853..21e3150 100644
--- a/util/src/main/java/com/ning/billing/util/svcapi/junction/DefaultBlockingState.java
+++ b/util/src/main/java/com/ning/billing/util/svcapi/junction/DefaultBlockingState.java
@@ -89,7 +89,7 @@ public class DefaultBlockingState extends EntityBase implements BlockingState {
              null);
     }
 
-
+    @Override
     public UUID getBlockedId() {
         return blockingId;
     }
@@ -115,6 +115,7 @@ public class DefaultBlockingState extends EntityBase implements BlockingState {
         return timestamp;
     }
 
+    @Override
     public String getService() {
         return service;
     }