Remove getCashBalances first part

More removal of getCashBalances

Get rid of duplicated code

Move onto new getCashBalance extension methods

Move onto new getCashBalance extension methods

Correct balance query code

Address PR request comments

Address PR request comments

Address PR request comments

client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java

@@ -2,14 +2,10 @@ package net.corda.client.rpc;
 
 import com.google.common.util.concurrent.ListenableFuture;
 import net.corda.client.rpc.internal.RPCClient;
-import net.corda.contracts.asset.Cash;
 import net.corda.core.contracts.Amount;
 import net.corda.core.messaging.CordaRPCOps;
 import net.corda.core.messaging.FlowHandle;
 import net.corda.core.node.services.ServiceInfo;
-import net.corda.core.node.services.Vault;
-import net.corda.core.node.services.vault.Builder;
-import net.corda.core.node.services.vault.QueryCriteria;
 import net.corda.core.utilities.OpaqueBytes;
 import net.corda.flows.AbstractCashFlow;
 import net.corda.flows.CashIssueFlow;
@@ -17,20 +13,18 @@ import net.corda.flows.CashPaymentFlow;
 import net.corda.node.internal.Node;
 import net.corda.node.services.transactions.ValidatingNotaryService;
 import net.corda.nodeapi.User;
-import net.corda.schemas.CashSchemaV1;
 import net.corda.testing.node.NodeBasedTest;
 import org.junit.After;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.io.IOException;
-import java.lang.reflect.Field;
 import java.util.*;
 import java.util.concurrent.ExecutionException;
 
 import static kotlin.test.AssertionsKt.assertEquals;
 import static net.corda.client.rpc.CordaRPCClientConfiguration.getDefault;
+import static net.corda.contracts.GetBalances.getCashBalance;
 import static net.corda.node.services.RPCUserServiceKt.startFlowPermission;
 import static net.corda.testing.TestConstants.getALICE;
 
@@ -79,24 +73,9 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
         System.out.println("Started issuing cash, waiting on result");
         flowHandle.getReturnValue().get();
 
-        Amount<Currency> balance = getBalance(Currency.getInstance("USD"));
+        Amount<Currency> balance = getCashBalance(rpcProxy, Currency.getInstance("USD"));
         System.out.print("Balance: " + balance + "\n");
 
         assertEquals(dollars123, balance, "matching");
     }
-
-    private Amount<Currency> getBalance(Currency currency) throws NoSuchFieldException {
-        Field pennies = CashSchemaV1.PersistentCashState.class.getDeclaredField("pennies");
-        @SuppressWarnings("unchecked")
-        QueryCriteria sumCriteria = new QueryCriteria.VaultCustomQueryCriteria(Builder.sum(pennies));
-
-        Vault.Page<Cash.State> results = rpcProxy.vaultQueryByCriteria(sumCriteria, Cash.State.class);
-        if (results.getOtherResults().isEmpty()) {
-            return new Amount<>(0L, currency);
-        } else {
-            Assert.assertNotNull(results.getOtherResults());
-            Long quantity = (Long) results.getOtherResults().get(0);
-            return new Amount<>(quantity, currency);
-        }
-    }
 }

client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt

@@ -1,7 +1,7 @@
 package net.corda.client.rpc
 
-import net.corda.contracts.asset.Cash
-import net.corda.core.contracts.Amount
+import net.corda.contracts.getCashBalance
+import net.corda.contracts.getCashBalances
 import net.corda.core.contracts.DOLLARS
 import net.corda.core.contracts.USD
 import net.corda.core.crypto.random63BitValue
@@ -9,8 +9,6 @@ import net.corda.core.flows.FlowInitiator
 import net.corda.core.getOrThrow
 import net.corda.core.messaging.*
 import net.corda.core.node.services.ServiceInfo
-import net.corda.core.node.services.vault.QueryCriteria
-import net.corda.core.node.services.vault.builder
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.flows.CashException
 import net.corda.flows.CashIssueFlow
@@ -19,16 +17,13 @@ import net.corda.node.internal.Node
 import net.corda.node.services.startFlowPermission
 import net.corda.node.services.transactions.ValidatingNotaryService
 import net.corda.nodeapi.User
-import net.corda.schemas.CashSchemaV1
 import net.corda.testing.ALICE
 import net.corda.testing.node.NodeBasedTest
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.After
-import org.junit.Assert
 import org.junit.Before
 import org.junit.Test
-import java.util.*
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
@@ -124,25 +119,11 @@ class CordaRPCClientTest : NodeBasedTest() {
         println("Started issuing cash, waiting on result")
         flowHandle.returnValue.get()
 
-        val cashDollars = getBalance(USD, proxy)
+        val cashDollars = proxy.getCashBalance(USD)
         println("Balance: $cashDollars")
         assertEquals(123.DOLLARS, cashDollars)
     }
 
-    private fun getBalance(currency: Currency, proxy: CordaRPCOps): Amount<Currency> {
-        val sum = builder { CashSchemaV1.PersistentCashState::pennies.sum() }
-        val sumCriteria = QueryCriteria.VaultCustomQueryCriteria(sum)
-
-        val results = proxy.vaultQueryBy<Cash.State>(sumCriteria)
-        if (results.otherResults.isEmpty()) {
-            return Amount(0L, currency)
-        } else {
-            Assert.assertNotNull(results.otherResults)
-            val quantity = results.otherResults[0] as Long
-            return Amount(quantity, currency)
-        }
-    }
-
     @Test
     fun `flow initiator via RPC`() {
         login(rpcUser.username, rpcUser.password)

client/rpc/src/smoke-test/java/net/corda/java/rpc/StandaloneCordaRPCJavaClientTest.java

@@ -1,26 +1,29 @@
 package net.corda.java.rpc;
 
-import net.corda.client.rpc.*;
-import net.corda.contracts.asset.*;
-import net.corda.core.contracts.*;
-import net.corda.core.messaging.*;
-import net.corda.core.node.*;
-import net.corda.core.node.services.*;
-import net.corda.core.node.services.vault.*;
-import net.corda.core.utilities.*;
-import net.corda.flows.*;
-import net.corda.nodeapi.*;
-import net.corda.schemas.*;
-import net.corda.smoketesting.*;
-import org.bouncycastle.asn1.x500.*;
-import org.junit.*;
+import net.corda.client.rpc.CordaRPCConnection;
+import net.corda.core.contracts.Amount;
+import net.corda.core.messaging.CordaRPCOps;
+import net.corda.core.messaging.DataFeed;
+import net.corda.core.messaging.FlowHandle;
+import net.corda.core.node.NodeInfo;
+import net.corda.core.node.services.NetworkMapCache;
+import net.corda.core.utilities.OpaqueBytes;
+import net.corda.flows.AbstractCashFlow;
+import net.corda.flows.CashIssueFlow;
+import net.corda.nodeapi.User;
+import net.corda.smoketesting.NodeConfig;
+import net.corda.smoketesting.NodeProcess;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 
-import java.lang.reflect.*;
 import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static kotlin.test.AssertionsKt.assertEquals;
+import static net.corda.contracts.GetBalances.getCashBalance;
 
 public class StandaloneCordaRPCJavaClientTest {
     private List<String> perms = Collections.singletonList("ALL");
@@ -76,24 +79,9 @@ public class StandaloneCordaRPCJavaClientTest {
         System.out.println("Started issuing cash, waiting on result");
         flowHandle.getReturnValue().get();
 
-        Amount<Currency> balance = getBalance(Currency.getInstance("USD"));
+        Amount<Currency> balance = getCashBalance(rpcProxy, Currency.getInstance("USD"));
         System.out.print("Balance: " + balance + "\n");
 
         assertEquals(dollars123, balance, "matching");
     }
-
-    private Amount<Currency> getBalance(Currency currency) throws NoSuchFieldException {
-        Field pennies = CashSchemaV1.PersistentCashState.class.getDeclaredField("pennies");
-        @SuppressWarnings("unchecked")
-        QueryCriteria sumCriteria = new QueryCriteria.VaultCustomQueryCriteria(Builder.sum(pennies));
-
-        Vault.Page<Cash.State> results = rpcProxy.vaultQueryByCriteria(sumCriteria, Cash.State.class);
-        if (results.getOtherResults().isEmpty()) {
-            return new Amount<>(0L, currency);
-        } else {
-            Assert.assertNotNull(results.getOtherResults());
-            Long quantity = (Long) results.getOtherResults().get(0);
-            return new Amount<>(quantity, currency);
-        }
-    }
 }

client/rpc/src/smoke-test/kotlin/net/corda/kotlin/rpc/StandaloneCordaRPClientTest.kt

@@ -5,21 +5,22 @@ import com.google.common.hash.HashingInputStream
 import net.corda.client.rpc.CordaRPCConnection
 import net.corda.client.rpc.notUsed
 import net.corda.contracts.asset.Cash
-import net.corda.core.internal.InputStreamAndHash
+import net.corda.contracts.getCashBalance
+import net.corda.contracts.getCashBalances
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.getOrThrow
+import net.corda.core.internal.InputStreamAndHash
 import net.corda.core.messaging.*
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.Vault
 import net.corda.core.node.services.vault.*
-import net.corda.core.utilities.seconds
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.loggerFor
+import net.corda.core.utilities.seconds
 import net.corda.flows.CashIssueFlow
 import net.corda.flows.CashPaymentFlow
 import net.corda.nodeapi.User
-import net.corda.schemas.CashSchemaV1
 import net.corda.smoketesting.NodeConfig
 import net.corda.smoketesting.NodeProcess
 import org.apache.commons.io.output.NullOutputStream
@@ -120,18 +121,41 @@ class StandaloneCordaRPClientTest {
         val (stateMachines, updates) = rpcProxy.stateMachinesAndUpdates()
         assertEquals(0, stateMachines.size)
 
-        var updateCount = 0
+        val updateCount = AtomicInteger(0)
         updates.subscribe { update ->
             if (update is StateMachineUpdate.Added) {
                 log.info("StateMachine>> Id=${update.id}")
-                ++updateCount
+                updateCount.incrementAndGet()
             }
         }
 
         // Now issue some cash
         rpcProxy.startFlow(::CashIssueFlow, 513.SWISS_FRANCS, OpaqueBytes.of(0), notaryNode.legalIdentity, notaryNode.notaryIdentity)
             .returnValue.getOrThrow(timeout)
-        assertEquals(1, updateCount)
+        assertEquals(1, updateCount.get())
+    }
+
+    @Test
+    fun `test vault`() {
+        val (vault, vaultUpdates) = rpcProxy.vaultAndUpdates()
+        assertEquals(0, vault.size)
+
+        val updateCount = AtomicInteger(0)
+        vaultUpdates.subscribe { update ->
+            log.info("Vault>> FlowId=${update.flowId}")
+            updateCount.incrementAndGet()
+        }
+
+        // Now issue some cash
+        rpcProxy.startFlow(::CashIssueFlow, 629.POUNDS, OpaqueBytes.of(0), notaryNode.legalIdentity, notaryNode.notaryIdentity)
+            .returnValue.getOrThrow(timeout)
+        assertNotEquals(0, updateCount.get())
+
+        // Check that this cash exists in the vault
+        val cashState = rpcProxy.vaultQueryBy<Cash.State>(QueryCriteria.FungibleAssetQueryCriteria()).states.single()
+        log.info("Cash State: $cashState")
+
+        assertEquals(629.POUNDS, cashState.state.data.amount.withoutIssuer())
     }
 
     @Test
@@ -139,16 +163,16 @@ class StandaloneCordaRPClientTest {
         val (vault, vaultUpdates) = rpcProxy.vaultTrackBy<Cash.State>()
         assertEquals(0, vault.states.size)
 
-        var updateCount = 0
+        val updateCount = AtomicInteger(0)
         vaultUpdates.subscribe { update ->
             log.info("Vault>> FlowId=${update.flowId}")
-            ++updateCount
+            updateCount.incrementAndGet()
         }
 
         // Now issue some cash
         rpcProxy.startFlow(::CashIssueFlow, 629.POUNDS, OpaqueBytes.of(0), notaryNode.legalIdentity, notaryNode.notaryIdentity)
                 .returnValue.getOrThrow(timeout)
-        assertNotEquals(0, updateCount)
+        assertNotEquals(0, updateCount.get())
 
         // Check that this cash exists in the vault
         val cashBalance = rpcProxy.getCashBalances()
@@ -195,28 +219,11 @@ class StandaloneCordaRPClientTest {
         println("Started issuing cash, waiting on result")
         flowHandle.returnValue.get()
 
-        val balance = getBalance(USD)
+        val balance = rpcProxy.getCashBalance(USD)
         println("Balance: " + balance)
         assertEquals(629.DOLLARS, balance)
     }
 
-    private fun getBalance(currency: Currency): Amount<Currency> {
-        val sum = builder { CashSchemaV1.PersistentCashState::pennies.sum() }
-        val sumCriteria = QueryCriteria.VaultCustomQueryCriteria(sum)
-
-        val ccyIndex = builder { CashSchemaV1.PersistentCashState::currency.equal(currency.currencyCode) }
-        val ccyCriteria = QueryCriteria.VaultCustomQueryCriteria(ccyIndex)
-
-        val results = rpcProxy.vaultQueryBy<Cash.State>(sumCriteria.and(ccyCriteria))
-        if (results.otherResults.isEmpty()) {
-            return Amount(0L, currency)
-        } else {
-            @Suppress("UNCHECKED_CAST")
-            val quantity = results.otherResults[0] as Long
-            return Amount(quantity, currency)
-        }
-    }
-
     private fun fetchNotaryIdentity(): NodeInfo {
         val (nodeInfo, nodeUpdates) = rpcProxy.networkMapFeed()
         nodeUpdates.notUsed()