ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-05-31 22:50:53 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Remove DealState dependency inside Vault. Use the linearId.externalId for all ref data uses.

Browse Source 
Rename as per PR comments

Correct a comment
This commit is contained in:
Matthew Nesbit 2017-08-14 13:55:09 +01:00
parent 3ba42b4ccd
commit e546b554fc
18 changed files with 62 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteria.kt
View File

@ -4,7 +4,6 @@ package net.corda.core.node.services.vault
import net.corda.core.contracts.ContractState import net.corda.core.contracts.ContractState
import net.corda.core.contracts.StateRef import net.corda.core.contracts.StateRef
import net.corda.core.contracts.UniqueIdentifier
import net.corda.core.identity.AbstractParty import net.corda.core.identity.AbstractParty
import net.corda.core.node.services.Vault import net.corda.core.node.services.Vault
import net.corda.core.schemas.PersistentState import net.corda.core.schemas.PersistentState
@ -64,8 +63,8 @@ sealed class QueryCriteria {
* LinearStateQueryCriteria: provides query by attributes defined in [VaultSchema.VaultLinearState] * LinearStateQueryCriteria: provides query by attributes defined in [VaultSchema.VaultLinearState]
*/ */
data class LinearStateQueryCriteria @JvmOverloads constructor(val participants: List<AbstractParty>? = null, data class LinearStateQueryCriteria @JvmOverloads constructor(val participants: List<AbstractParty>? = null,
val linearId: List<UniqueIdentifier>? = null, val uuid: List<UUID>? = null,
val dealRef: List<String>? = null, val externalId: List<String>? = null,
override val status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED) : CommonQueryCriteria() { override val status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED) : CommonQueryCriteria() {
override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> { override fun visit(parser: IQueryCriteriaParser): Collection<Predicate> {
return parser.parseCriteria(this as CommonQueryCriteria).plus(parser.parseCriteria(this)) return parser.parseCriteria(this as CommonQueryCriteria).plus(parser.parseCriteria(this))

3
core/src/main/kotlin/net/corda/core/node/services/vault/QueryCriteriaUtils.kt
View File

@ -162,8 +162,7 @@ data class Sort(val columns: Collection<SortColumn>) {
enum class LinearStateAttribute(val attributeName: String) : Attribute { enum class LinearStateAttribute(val attributeName: String) : Attribute {
/** Vault Linear States */ /** Vault Linear States */
UUID("uuid"), UUID("uuid"),
EXTERNAL_ID("externalId"), EXTERNAL_ID("externalId")
DEAL_REFERENCE("dealReference")
} }
enum class FungibleStateAttribute(val attributeName: String) : Attribute { enum class FungibleStateAttribute(val attributeName: String) : Attribute {

7
docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt
View File

@ -5,15 +5,14 @@ import net.corda.core.contracts.StateAndRef
import net.corda.core.contracts.UniqueIdentifier import net.corda.core.contracts.UniqueIdentifier
import net.corda.core.node.ServiceHub import net.corda.core.node.ServiceHub
import net.corda.core.node.services.ServiceInfo import net.corda.core.node.services.ServiceInfo
import net.corda.core.node.services.Vault
import net.corda.core.node.services.queryBy import net.corda.core.node.services.queryBy
import net.corda.core.node.services.vault.QueryCriteria import net.corda.core.node.services.vault.QueryCriteria
import net.corda.core.toFuture import net.corda.core.toFuture
import net.corda.core.utilities.getOrThrow import net.corda.core.utilities.getOrThrow
import net.corda.testing.DUMMY_NOTARY
import net.corda.testing.DUMMY_NOTARY_KEY
import net.corda.node.services.network.NetworkMapService import net.corda.node.services.network.NetworkMapService
import net.corda.node.services.transactions.ValidatingNotaryService import net.corda.node.services.transactions.ValidatingNotaryService
import net.corda.testing.DUMMY_NOTARY
import net.corda.testing.DUMMY_NOTARY_KEY
import net.corda.testing.node.MockNetwork import net.corda.testing.node.MockNetwork
import org.junit.After import org.junit.After
import org.junit.Before import org.junit.Before
@ -28,7 +27,7 @@ class WorkflowTransactionBuildTutorialTest {
// Helper method to locate the latest Vault version of a LinearState // Helper method to locate the latest Vault version of a LinearState
private inline fun <reified T : LinearState> ServiceHub.latest(ref: UniqueIdentifier): StateAndRef<T> { private inline fun <reified T : LinearState> ServiceHub.latest(ref: UniqueIdentifier): StateAndRef<T> {
val linearHeads = vaultQueryService.queryBy<T>(QueryCriteria.LinearStateQueryCriteria(linearId = listOf(ref))) val linearHeads = vaultQueryService.queryBy<T>(QueryCriteria.LinearStateQueryCriteria(uuid = listOf(ref.id)))
return linearHeads.states.single() return linearHeads.states.single()
} }

6
finance/src/main/kotlin/net/corda/contracts/FinanceTypes.kt
View File

@ -13,9 +13,8 @@ import net.corda.core.contracts.CommandData
import net.corda.core.contracts.LinearState import net.corda.core.contracts.LinearState
import net.corda.core.contracts.StateAndRef import net.corda.core.contracts.StateAndRef
import net.corda.core.contracts.TokenizableAssetInfo import net.corda.core.contracts.TokenizableAssetInfo
import net.corda.core.identity.AbstractParty
import net.corda.core.identity.Party import net.corda.core.identity.Party
import net.corda.core.node.services.* import net.corda.core.node.services.ServiceType
import net.corda.core.serialization.CordaSerializable import net.corda.core.serialization.CordaSerializable
import net.corda.core.transactions.TransactionBuilder import net.corda.core.transactions.TransactionBuilder
import java.math.BigDecimal import java.math.BigDecimal
@ -391,9 +390,6 @@ data class Commodity(val commodityCode: String,
* implementation of general flows that manipulate many agreement types. * implementation of general flows that manipulate many agreement types.
*/ */
interface DealState : LinearState { interface DealState : LinearState {
/** Human readable well known reference (e.g. trade reference) */
val ref: String
/** /**
* Generate a partial transaction representing an agreement (command) to this deal, allowing a general * Generate a partial transaction representing an agreement (command) to this deal, allowing a general
* deal/agreement flow to generate the necessary transaction for potential implementations. * deal/agreement flow to generate the necessary transaction for potential implementations.

2
finance/src/main/kotlin/net/corda/flows/TwoPartyDealFlow.kt
View File

@ -174,7 +174,7 @@ object TwoPartyDealFlow {
// What is the seller trying to sell us? // What is the seller trying to sell us?
val autoOffer = handshake.payload val autoOffer = handshake.payload
val deal = autoOffer.dealBeingOffered val deal = autoOffer.dealBeingOffered
logger.trace { "Got deal request for: ${deal.ref}" } logger.trace { "Got deal request for: ${deal.linearId.externalId!!}" }
return handshake.copy(payload = autoOffer.copy(dealBeingOffered = deal)) return handshake.copy(payload = autoOffer.copy(dealBeingOffered = deal))
} }

11
node/src/main/kotlin/net/corda/node/services/schema/NodeSchemaService.kt
View File

@ -1,15 +1,14 @@
package net.corda.node.services.schema package net.corda.node.services.schema
import net.corda.contracts.DealState
import net.corda.core.contracts.ContractState import net.corda.core.contracts.ContractState
import net.corda.core.contracts.FungibleAsset import net.corda.core.contracts.FungibleAsset
import net.corda.core.contracts.LinearState import net.corda.core.contracts.LinearState
import net.corda.core.schemas.CommonSchemaV1
import net.corda.core.schemas.MappedSchema import net.corda.core.schemas.MappedSchema
import net.corda.core.schemas.PersistentState import net.corda.core.schemas.PersistentState
import net.corda.core.schemas.QueryableState import net.corda.core.schemas.QueryableState
import net.corda.core.serialization.SingletonSerializeAsToken import net.corda.core.serialization.SingletonSerializeAsToken
import net.corda.node.services.api.SchemaService import net.corda.node.services.api.SchemaService
import net.corda.core.schemas.CommonSchemaV1
import net.corda.node.services.keys.PersistentKeyManagementService import net.corda.node.services.keys.PersistentKeyManagementService
import net.corda.node.services.persistence.DBCheckpointStorage import net.corda.node.services.persistence.DBCheckpointStorage
import net.corda.node.services.persistence.DBTransactionMappingStorage import net.corda.node.services.persistence.DBTransactionMappingStorage
@ -59,9 +58,6 @@ class NodeSchemaService(customSchemas: Set<MappedSchema> = emptySet()) : SchemaS
schemas += state.supportedSchemas() schemas += state.supportedSchemas()
if (state is LinearState) if (state is LinearState)
schemas += VaultSchemaV1 // VaultLinearStates schemas += VaultSchemaV1 // VaultLinearStates
// TODO: DealState to be deprecated (collapsed into LinearState)
if (state is DealState)
schemas += VaultSchemaV1 // VaultLinearStates
if (state is FungibleAsset<*>) if (state is FungibleAsset<*>)
schemas += VaultSchemaV1 // VaultFungibleStates schemas += VaultSchemaV1 // VaultFungibleStates
@ -70,11 +66,8 @@ class NodeSchemaService(customSchemas: Set<MappedSchema> = emptySet()) : SchemaS
// Because schema is always one supported by the state, just delegate. // Because schema is always one supported by the state, just delegate.
override fun generateMappedObject(state: ContractState, schema: MappedSchema): PersistentState { override fun generateMappedObject(state: ContractState, schema: MappedSchema): PersistentState {
// TODO: DealState to be deprecated (collapsed into LinearState)
if ((schema is VaultSchemaV1) && (state is DealState))
return VaultSchemaV1.VaultLinearStates(state.linearId, state.ref, state.participants)
if ((schema is VaultSchemaV1) && (state is LinearState)) if ((schema is VaultSchemaV1) && (state is LinearState))
return VaultSchemaV1.VaultLinearStates(state.linearId, "", state.participants) return VaultSchemaV1.VaultLinearStates(state.linearId, state.participants)
if ((schema is VaultSchemaV1) && (state is FungibleAsset<*>)) if ((schema is VaultSchemaV1) && (state is FungibleAsset<*>))
return VaultSchemaV1.VaultFungibleStates(state.owner, state.amount.quantity, state.amount.token.issuer.party, state.amount.token.issuer.reference, state.participants) return VaultSchemaV1.VaultFungibleStates(state.owner, state.amount.quantity, state.amount.token.issuer.party, state.amount.token.issuer.reference, state.participants)
return (state as QueryableState).generateMappedObject(schema) return (state as QueryableState).generateMappedObject(schema)

28
node/src/main/kotlin/net/corda/node/services/vault/HibernateQueryCriteriaParser.kt
View File

@ -2,7 +2,6 @@ package net.corda.node.services.vault
import net.corda.core.contracts.ContractState import net.corda.core.contracts.ContractState
import net.corda.core.contracts.StateRef import net.corda.core.contracts.StateRef
import net.corda.core.contracts.UniqueIdentifier
import net.corda.core.identity.AbstractParty import net.corda.core.identity.AbstractParty
import net.corda.core.node.services.Vault import net.corda.core.node.services.Vault
import net.corda.core.node.services.VaultQueryException import net.corda.core.node.services.VaultQueryException
@ -229,7 +228,7 @@ class HibernateQueryCriteriaParser(val contractType: Class<out ContractState>,
override fun parseCriteria(criteria: QueryCriteria.FungibleAssetQueryCriteria) : Collection<Predicate> { override fun parseCriteria(criteria: QueryCriteria.FungibleAssetQueryCriteria) : Collection<Predicate> {
log.trace { "Parsing FungibleAssetQueryCriteria: $criteria" } log.trace { "Parsing FungibleAssetQueryCriteria: $criteria" }
var predicateSet = mutableSetOf<Predicate>() val predicateSet = mutableSetOf<Predicate>()
val vaultFungibleStates = criteriaQuery.from(VaultSchemaV1.VaultFungibleStates::class.java) val vaultFungibleStates = criteriaQuery.from(VaultSchemaV1.VaultFungibleStates::class.java)
rootEntities.putIfAbsent(VaultSchemaV1.VaultFungibleStates::class.java, vaultFungibleStates) rootEntities.putIfAbsent(VaultSchemaV1.VaultFungibleStates::class.java, vaultFungibleStates)
@ -296,19 +295,16 @@ class HibernateQueryCriteriaParser(val contractType: Class<out ContractState>,
if (contractTypes.isNotEmpty()) if (contractTypes.isNotEmpty())
predicateSet.add(criteriaBuilder.and(vaultStates.get<String>("contractStateClassName").`in`(contractTypes))) predicateSet.add(criteriaBuilder.and(vaultStates.get<String>("contractStateClassName").`in`(contractTypes)))
// linear ids // linear ids UUID
criteria.linearId?.let { criteria.uuid?.let {
val uniqueIdentifiers = criteria.linearId as List<UniqueIdentifier> val uuids = criteria.uuid as List<UUID>
val externalIds = uniqueIdentifiers.mapNotNull { it.externalId } predicateSet.add(criteriaBuilder.and(vaultLinearStates.get<UUID>("uuid").`in`(uuids)))
if (externalIds.isNotEmpty())
predicateSet.add(criteriaBuilder.and(vaultLinearStates.get<String>("externalId").`in`(externalIds)))
predicateSet.add(criteriaBuilder.and(vaultLinearStates.get<UUID>("uuid").`in`(uniqueIdentifiers.map { it.id })))
} }
// deal refs // linear ids externalId
criteria.dealRef?.let { criteria.externalId?.let {
val dealRefs = criteria.dealRef as List<String> val externalIds = criteria.externalId as List<String>
predicateSet.add(criteriaBuilder.and(vaultLinearStates.get<String>("dealReference").`in`(dealRefs))) predicateSet.add(criteriaBuilder.and(vaultLinearStates.get<String>("externalId").`in`(externalIds)))
} }
// deal participants // deal participants
@ -359,7 +355,7 @@ class HibernateQueryCriteriaParser(val contractType: Class<out ContractState>,
override fun parseOr(left: QueryCriteria, right: QueryCriteria): Collection<Predicate> { override fun parseOr(left: QueryCriteria, right: QueryCriteria): Collection<Predicate> {
log.trace { "Parsing OR QueryCriteria composition: $left OR $right" } log.trace { "Parsing OR QueryCriteria composition: $left OR $right" }
var predicateSet = mutableSetOf<Predicate>() val predicateSet = mutableSetOf<Predicate>()
val leftPredicates = parse(left) val leftPredicates = parse(left)
val rightPredicates = parse(right) val rightPredicates = parse(right)
@ -372,7 +368,7 @@ class HibernateQueryCriteriaParser(val contractType: Class<out ContractState>,
override fun parseAnd(left: QueryCriteria, right: QueryCriteria): Collection<Predicate> { override fun parseAnd(left: QueryCriteria, right: QueryCriteria): Collection<Predicate> {
log.trace { "Parsing AND QueryCriteria composition: $left AND $right" } log.trace { "Parsing AND QueryCriteria composition: $left AND $right" }
var predicateSet = mutableSetOf<Predicate>() val predicateSet = mutableSetOf<Predicate>()
val leftPredicates = parse(left) val leftPredicates = parse(left)
val rightPredicates = parse(right) val rightPredicates = parse(right)
@ -417,7 +413,7 @@ class HibernateQueryCriteriaParser(val contractType: Class<out ContractState>,
private fun parse(sorting: Sort) { private fun parse(sorting: Sort) {
log.trace { "Parsing sorting specification: $sorting" } log.trace { "Parsing sorting specification: $sorting" }
var orderCriteria = mutableListOf<Order>() val orderCriteria = mutableListOf<Order>()
sorting.columns.map { (sortAttribute, direction) -> sorting.columns.map { (sortAttribute, direction) ->
val (entityStateClass, entityStateAttributeParent, entityStateAttributeChild) = val (entityStateClass, entityStateAttributeParent, entityStateAttributeChild) =

2
node/src/main/kotlin/net/corda/node/services/vault/NodeVaultService.kt
View File

@ -5,9 +5,7 @@ import co.paralleluniverse.strands.Strand
import com.google.common.annotations.VisibleForTesting import com.google.common.annotations.VisibleForTesting
import io.requery.PersistenceException import io.requery.PersistenceException
import io.requery.kotlin.eq import io.requery.kotlin.eq
import io.requery.kotlin.notNull
import io.requery.query.RowExpression import io.requery.query.RowExpression
import net.corda.contracts.asset.Cash
import net.corda.core.contracts.* import net.corda.core.contracts.*
import net.corda.core.crypto.SecureHash import net.corda.core.crypto.SecureHash
import net.corda.core.crypto.containsAny import net.corda.core.crypto.containsAny

14
node/src/main/kotlin/net/corda/node/services/vault/VaultSchema.kt
View File

@ -68,8 +68,7 @@ object VaultSchemaV1 : MappedSchema(schemaFamily = VaultSchema.javaClass, versio
@Entity @Entity
@Table(name = "vault_linear_states", @Table(name = "vault_linear_states",
indexes = arrayOf(Index(name = "external_id_index", columnList = "external_id"), indexes = arrayOf(Index(name = "external_id_index", columnList = "external_id"),
Index(name = "uuid_index", columnList = "uuid"), Index(name = "uuid_index", columnList = "uuid")))
Index(name = "deal_reference_index", columnList = "deal_reference")))
class VaultLinearStates( class VaultLinearStates(
/** [ContractState] attributes */ /** [ContractState] attributes */
@OneToMany(cascade = arrayOf(CascadeType.ALL)) @OneToMany(cascade = arrayOf(CascadeType.ALL))
@ -82,18 +81,11 @@ object VaultSchemaV1 : MappedSchema(schemaFamily = VaultSchema.javaClass, versio
var externalId: String?, var externalId: String?,
@Column(name = "uuid", nullable = false) @Column(name = "uuid", nullable = false)
var uuid: UUID, var uuid: UUID
// TODO: DealState to be deprecated (collapsed into LinearState)
/** Deal State attributes **/
@Column(name = "deal_reference")
var dealReference: String
) : PersistentState() { ) : PersistentState() {
constructor(uid: UniqueIdentifier, _dealReference: String, _participants: List<AbstractParty>) : constructor(uid: UniqueIdentifier, _participants: List<AbstractParty>) :
this(externalId = uid.externalId, this(externalId = uid.externalId,
uuid = uid.id, uuid = uid.id,
dealReference = _dealReference,
participants = _participants.map{ CommonSchemaV1.Party(it) }.toSet() ) participants = _participants.map{ CommonSchemaV1.Party(it) }.toSet() )
} }

4
node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java
View File

@ -171,7 +171,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
QueryCriteria vaultCriteria = new VaultQueryCriteria(status, contractStateTypes); QueryCriteria vaultCriteria = new VaultQueryCriteria(status, contractStateTypes);
List<UniqueIdentifier> linearIds = Collections.singletonList(uid); List<UUID> linearIds = Collections.singletonList(uid.getId());
QueryCriteria linearCriteriaAll = new LinearStateQueryCriteria(null, linearIds); QueryCriteria linearCriteriaAll = new LinearStateQueryCriteria(null, linearIds);
QueryCriteria dealCriteriaAll = new LinearStateQueryCriteria(null, null, dealIds); QueryCriteria dealCriteriaAll = new LinearStateQueryCriteria(null, null, dealIds);
@ -281,7 +281,7 @@ public class VaultQueryJavaTests extends TestDependencyInjectionBase {
Set<Class<ContractState>> contractStateTypes = new HashSet(Arrays.asList(DealState.class, LinearState.class)); Set<Class<ContractState>> contractStateTypes = new HashSet(Arrays.asList(DealState.class, LinearState.class));
QueryCriteria vaultCriteria = new VaultQueryCriteria(Vault.StateStatus.UNCONSUMED, contractStateTypes); QueryCriteria vaultCriteria = new VaultQueryCriteria(Vault.StateStatus.UNCONSUMED, contractStateTypes);
List<UniqueIdentifier> linearIds = Collections.singletonList(uid); List<UUID> linearIds = Collections.singletonList(uid.getId());
List<AbstractParty> dealParty = Collections.singletonList(getMEGA_CORP()); List<AbstractParty> dealParty = Collections.singletonList(getMEGA_CORP());
QueryCriteria dealCriteria = new LinearStateQueryCriteria(dealParty, null, dealIds); QueryCriteria dealCriteria = new LinearStateQueryCriteria(dealParty, null, dealIds);
QueryCriteria linearCriteria = new LinearStateQueryCriteria(dealParty, linearIds, null); QueryCriteria linearCriteria = new LinearStateQueryCriteria(dealParty, linearIds, null);

42
node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
View File

@ -14,10 +14,6 @@ import net.corda.core.identity.Party
import net.corda.core.node.services.* import net.corda.core.node.services.*
import net.corda.core.node.services.vault.* import net.corda.core.node.services.vault.*
import net.corda.core.node.services.vault.QueryCriteria.* import net.corda.core.node.services.vault.QueryCriteria.*
import net.corda.core.utilities.seconds
import net.corda.core.utilities.NonEmptySet
import net.corda.core.utilities.OpaqueBytes
import net.corda.core.utilities.toHexString
import net.corda.core.utilities.* import net.corda.core.utilities.*
import net.corda.node.utilities.CordaPersistence import net.corda.node.utilities.CordaPersistence
import net.corda.node.utilities.configureDatabase import net.corda.node.utilities.configureDatabase
@ -99,7 +95,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
// consume some states // consume some states
services.consumeLinearStates(linearStatesXYZ.states.toList(), DUMMY_NOTARY) services.consumeLinearStates(linearStatesXYZ.states.toList(), DUMMY_NOTARY)
services.consumeLinearStates(linearStatesJKL.states.toList(), DUMMY_NOTARY) services.consumeLinearStates(linearStatesJKL.states.toList(), DUMMY_NOTARY)
services.consumeDeals(dealStates.states.filter { it.state.data.ref == "456" }, DUMMY_NOTARY) services.consumeDeals(dealStates.states.filter { it.state.data.linearId.externalId == "456" }, DUMMY_NOTARY)
services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY) services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY)
// Total unconsumed states = 4 + 3 + 2 + 1 (new cash change) = 10 // Total unconsumed states = 4 + 3 + 2 + 1 (new cash change) = 10
@ -328,7 +324,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
val dealStates = services.fillWithSomeTestDeals(listOf("123", "456", "789")) val dealStates = services.fillWithSomeTestDeals(listOf("123", "456", "789"))
services.consumeLinearStates(linearStates.states.toList(), DUMMY_NOTARY) services.consumeLinearStates(linearStates.states.toList(), DUMMY_NOTARY)
services.consumeDeals(dealStates.states.filter { it.state.data.ref == "456" }, DUMMY_NOTARY) services.consumeDeals(dealStates.states.filter { it.state.data.linearId.externalId == "456" }, DUMMY_NOTARY)
services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY) services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY)
val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED) val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
@ -370,7 +366,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
val dealStates = services.fillWithSomeTestDeals(listOf("123", "456", "789")) val dealStates = services.fillWithSomeTestDeals(listOf("123", "456", "789"))
services.consumeLinearStates(linearStates.states.toList(), DUMMY_NOTARY) services.consumeLinearStates(linearStates.states.toList(), DUMMY_NOTARY)
services.consumeDeals(dealStates.states.filter { it.state.data.ref == "456" }, DUMMY_NOTARY) services.consumeDeals(dealStates.states.filter { it.state.data.linearId.externalId == "456" }, DUMMY_NOTARY)
services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY) // generates a new change state! services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY) // generates a new change state!
val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL) val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
@ -883,7 +879,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
// consume some states // consume some states
services.consumeLinearStates(linearStatesXYZ.states.toList(), DUMMY_NOTARY) services.consumeLinearStates(linearStatesXYZ.states.toList(), DUMMY_NOTARY)
services.consumeLinearStates(linearStatesJKL.states.toList(), DUMMY_NOTARY) services.consumeLinearStates(linearStatesJKL.states.toList(), DUMMY_NOTARY)
services.consumeDeals(dealStates.states.filter { it.state.data.ref == "456" }, DUMMY_NOTARY) services.consumeDeals(dealStates.states.filter { it.state.data.linearId.externalId == "456" }, DUMMY_NOTARY)
val cashUpdates = services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY) val cashUpdates = services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY)
// UNCONSUMED states (default) // UNCONSUMED states (default)
@ -1171,7 +1167,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
val dealStates = services.fillWithSomeTestDeals(listOf("123", "456", "789")) val dealStates = services.fillWithSomeTestDeals(listOf("123", "456", "789"))
services.consumeLinearStates(linearStates.states.toList(), DUMMY_NOTARY) services.consumeLinearStates(linearStates.states.toList(), DUMMY_NOTARY)
services.consumeDeals(dealStates.states.filter { it.state.data.ref == "456" }, DUMMY_NOTARY) services.consumeDeals(dealStates.states.filter { it.state.data.linearId.externalId == "456" }, DUMMY_NOTARY)
services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY) services.consumeCash(50.DOLLARS, notary = DUMMY_NOTARY)
val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED) val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
@ -1189,8 +1185,8 @@ class VaultQueryTests : TestDependencyInjectionBase() {
val issuedStates = services.fillWithSomeTestLinearStates(10) val issuedStates = services.fillWithSomeTestLinearStates(10)
// DOCSTART VaultQueryExample8 // DOCSTART VaultQueryExample8
val linearIds = issuedStates.states.map { it.state.data.linearId }.toList() val linearIds = issuedStates.states.map { it.state.data.linearId.id }.toList()
val criteria = LinearStateQueryCriteria(linearId = listOf(linearIds.first(), linearIds.last())) val criteria = LinearStateQueryCriteria(uuid = listOf(linearIds.first(), linearIds.last()))
val results = vaultQuerySvc.queryBy<LinearState>(criteria) val results = vaultQuerySvc.queryBy<LinearState>(criteria)
// DOCEND VaultQueryExample8 // DOCEND VaultQueryExample8
assertThat(results.states).hasSize(2) assertThat(results.states).hasSize(2)
@ -1205,8 +1201,8 @@ class VaultQueryTests : TestDependencyInjectionBase() {
services.fillWithSomeTestLinearStates(1, "ID2") services.fillWithSomeTestLinearStates(1, "ID2")
val linearState3 = services.fillWithSomeTestLinearStates(1, "ID3") val linearState3 = services.fillWithSomeTestLinearStates(1, "ID3")
val linearIds = listOf(linearState1.states.first().state.data.linearId, linearState3.states.first().state.data.linearId) val linearIds = listOf(linearState1.states.first().state.data.linearId.id, linearState3.states.first().state.data.linearId.id)
val criteria = LinearStateQueryCriteria(linearId = linearIds) val criteria = LinearStateQueryCriteria(uuid = linearIds)
val results = vaultQuerySvc.queryBy<LinearState>(criteria) val results = vaultQuerySvc.queryBy<LinearState>(criteria)
assertThat(results.states).hasSize(2) assertThat(results.states).hasSize(2)
} }
@ -1225,7 +1221,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
// should now have 1 UNCONSUMED & 3 CONSUMED state refs for Linear State with "TEST" // should now have 1 UNCONSUMED & 3 CONSUMED state refs for Linear State with "TEST"
// DOCSTART VaultQueryExample9 // DOCSTART VaultQueryExample9
val linearStateCriteria = LinearStateQueryCriteria(linearId = listOf(linearId), status = Vault.StateStatus.ALL) val linearStateCriteria = LinearStateQueryCriteria(uuid = listOf(linearId.id), status = Vault.StateStatus.ALL)
val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.ALL) val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria and vaultCriteria) val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria and vaultCriteria)
// DOCEND VaultQueryExample9 // DOCEND VaultQueryExample9
@ -1244,7 +1240,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
services.evolveLinearStates(linearStates, DUMMY_NOTARY) // consume current and produce new state reference services.evolveLinearStates(linearStates, DUMMY_NOTARY) // consume current and produce new state reference
// should now have 1 UNCONSUMED & 3 CONSUMED state refs for Linear State with "TEST" // should now have 1 UNCONSUMED & 3 CONSUMED state refs for Linear State with "TEST"
val linearStateCriteria = LinearStateQueryCriteria(linearId = linearStates.map { it.state.data.linearId }, status = Vault.StateStatus.ALL) val linearStateCriteria = LinearStateQueryCriteria(uuid = linearStates.map { it.state.data.linearId.id }, status = Vault.StateStatus.ALL)
val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.ALL) val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC))) val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC)))
@ -1266,7 +1262,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.EXTERNAL_ID), Sort.Direction.DESC))) val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.EXTERNAL_ID), Sort.Direction.DESC)))
val results = vaultQuerySvc.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting) val results = vaultQuerySvc.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting)
results.states.forEach { println("${it.state.data.linearString}") } results.states.forEach { println(it.state.data.linearString) }
assertThat(results.states).hasSize(6) assertThat(results.states).hasSize(6)
} }
} }
@ -1276,14 +1272,14 @@ class VaultQueryTests : TestDependencyInjectionBase() {
database.transaction { database.transaction {
val linearStates = services.fillWithSomeTestLinearStates(10) val linearStates = services.fillWithSomeTestLinearStates(10)
val uid = linearStates.states.first().state.data.linearId val uid = linearStates.states.first().state.data.linearId.id
services.fillWithSomeTestDeals(listOf("123", "456", "789")) services.fillWithSomeTestDeals(listOf("123", "456", "789"))
val linearStateCriteria = LinearStateQueryCriteria(linearId = listOf(uid)) val linearStateCriteria = LinearStateQueryCriteria(uuid = listOf(uid))
val dealStateCriteria = LinearStateQueryCriteria(dealRef = listOf("123", "456", "789")) val dealStateCriteria = LinearStateQueryCriteria(externalId = listOf("123", "456", "789"))
val compositeCriteria = linearStateCriteria or dealStateCriteria val compositeCriteria = linearStateCriteria or dealStateCriteria
val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.DEAL_REFERENCE), Sort.Direction.DESC))) val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.EXTERNAL_ID), Sort.Direction.DESC)))
val results = vaultQuerySvc.queryBy<LinearState>(compositeCriteria, sorting = sorting) val results = vaultQuerySvc.queryBy<LinearState>(compositeCriteria, sorting = sorting)
assertThat(results.statesMetadata).hasSize(13) assertThat(results.statesMetadata).hasSize(13)
@ -1319,7 +1315,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
services.evolveLinearState(linearState3, DUMMY_NOTARY) // consume current and produce new state reference services.evolveLinearState(linearState3, DUMMY_NOTARY) // consume current and produce new state reference
// should now have 1 UNCONSUMED & 3 CONSUMED state refs for Linear State with "TEST" // should now have 1 UNCONSUMED & 3 CONSUMED state refs for Linear State with "TEST"
val linearStateCriteria = LinearStateQueryCriteria(linearId = txns.states.map { it.state.data.linearId }, status = Vault.StateStatus.CONSUMED) val linearStateCriteria = LinearStateQueryCriteria(uuid = txns.states.map { it.state.data.linearId.id }, status = Vault.StateStatus.CONSUMED)
val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED) val vaultCriteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC))) val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC)))
val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria.and(vaultCriteria), sorting = sorting) val results = vaultQuerySvc.queryBy<LinearState>(linearStateCriteria.and(vaultCriteria), sorting = sorting)
@ -1348,7 +1344,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
services.fillWithSomeTestDeals(listOf("123", "456", "789")) services.fillWithSomeTestDeals(listOf("123", "456", "789"))
// DOCSTART VaultQueryExample10 // DOCSTART VaultQueryExample10
val criteria = LinearStateQueryCriteria(dealRef = listOf("456", "789")) val criteria = LinearStateQueryCriteria(externalId = listOf("456", "789"))
val results = vaultQuerySvc.queryBy<DealState>(criteria) val results = vaultQuerySvc.queryBy<DealState>(criteria)
// DOCEND VaultQueryExample10 // DOCEND VaultQueryExample10
@ -1367,7 +1363,7 @@ class VaultQueryTests : TestDependencyInjectionBase() {
val all = vaultQuerySvc.queryBy<DealState>() val all = vaultQuerySvc.queryBy<DealState>()
all.states.forEach { println(it.state) } all.states.forEach { println(it.state) }
val criteria = LinearStateQueryCriteria(dealRef = listOf("456")) val criteria = LinearStateQueryCriteria(externalId = listOf("456"))
val results = vaultQuerySvc.queryBy<DealState>(criteria) val results = vaultQuerySvc.queryBy<DealState>(criteria)
assertThat(results.states).hasSize(1) assertThat(results.states).hasSize(1)
} }

7
node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt
View File

@ -13,9 +13,6 @@ import net.corda.core.node.services.queryBy
import net.corda.core.node.services.vault.QueryCriteria import net.corda.core.node.services.vault.QueryCriteria
import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria
import net.corda.core.transactions.TransactionBuilder import net.corda.core.transactions.TransactionBuilder
import net.corda.node.services.database.HibernateConfiguration
import net.corda.node.services.identity.InMemoryIdentityService
import net.corda.node.services.schema.NodeSchemaService
import net.corda.node.utilities.CordaPersistence import net.corda.node.utilities.CordaPersistence
import net.corda.testing.* import net.corda.testing.*
import net.corda.testing.contracts.* import net.corda.testing.contracts.*
@ -278,7 +275,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
services.fillWithSomeTestDeals(listOf("123", "456", "789")) services.fillWithSomeTestDeals(listOf("123", "456", "789"))
val deals = vaultQuery.queryBy<DummyDealContract.State>().states val deals = vaultQuery.queryBy<DummyDealContract.State>().states
deals.forEach { println(it.state.data.ref) } deals.forEach { println(it.state.data.linearId.externalId!!) }
} }
database.transaction { database.transaction {
@ -306,7 +303,7 @@ class VaultWithCashTest : TestDependencyInjectionBase() {
services.fillWithSomeTestDeals(listOf("123", "456", "789")) services.fillWithSomeTestDeals(listOf("123", "456", "789"))
val deals = vaultQuery.queryBy<DummyDealContract.State>().states val deals = vaultQuery.queryBy<DummyDealContract.State>().states
deals.forEach { println(it.state.data.ref) } deals.forEach { println(it.state.data.linearId.externalId!!) }
services.fillWithSomeTestLinearStates(3) services.fillWithSomeTestLinearStates(3)
val linearStates = vaultQuery.queryBy<DummyLinearContract.State>().states val linearStates = vaultQuery.queryBy<DummyLinearContract.State>().states

4
samples/irs-demo/src/main/kotlin/net/corda/irs/api/InterestRateSwapAPI.kt
View File

@ -3,8 +3,8 @@ package net.corda.irs.api
import net.corda.core.contracts.filterStatesOfType import net.corda.core.contracts.filterStatesOfType
import net.corda.core.messaging.CordaRPCOps import net.corda.core.messaging.CordaRPCOps
import net.corda.core.messaging.startFlow import net.corda.core.messaging.startFlow
import net.corda.core.utilities.getOrThrow
import net.corda.core.messaging.vaultQueryBy import net.corda.core.messaging.vaultQueryBy
import net.corda.core.utilities.getOrThrow
import net.corda.core.utilities.loggerFor import net.corda.core.utilities.loggerFor
import net.corda.irs.contract.InterestRateSwap import net.corda.irs.contract.InterestRateSwap
import net.corda.irs.flows.AutoOfferFlow import net.corda.irs.flows.AutoOfferFlow
@ -37,7 +37,7 @@ class InterestRateSwapAPI(val rpc: CordaRPCOps) {
private fun getDealByRef(ref: String): InterestRateSwap.State? { private fun getDealByRef(ref: String): InterestRateSwap.State? {
val vault = rpc.vaultQueryBy<InterestRateSwap.State>().states val vault = rpc.vaultQueryBy<InterestRateSwap.State>().states
val states = vault.filterStatesOfType<InterestRateSwap.State>().filter { it.state.data.ref == ref } val states = vault.filterStatesOfType<InterestRateSwap.State>().filter { it.state.data.linearId.externalId == ref }
return if (states.isEmpty()) null else { return if (states.isEmpty()) null else {
val deals = states.map { it.state.data } val deals = states.map { it.state.data }
return if (deals.isEmpty()) null else deals[0] return if (deals.isEmpty()) null else deals[0]

4
samples/irs-demo/src/main/kotlin/net/corda/irs/contract/IRS.kt
View File

@ -567,7 +567,7 @@ class InterestRateSwap : Contract {
requireNotNull(tx.timeWindow) { "must be have a time-window)" } requireNotNull(tx.timeWindow) { "must be have a time-window)" }
val groups: List<LedgerTransaction.InOutGroup<State, UniqueIdentifier>> = tx.groupStates { state -> state.linearId } val groups: List<LedgerTransaction.InOutGroup<State, UniqueIdentifier>> = tx.groupStates { state -> state.linearId }
var atLeastOneCommandProcessed = false var atLeastOneCommandProcessed = false
for ((inputs, outputs, key) in groups) { for ((inputs, outputs, _) in groups) {
val agreeCommand = tx.commands.select<Commands.Agree>().firstOrNull() val agreeCommand = tx.commands.select<Commands.Agree>().firstOrNull()
if (agreeCommand != null) { if (agreeCommand != null) {
verifyAgreeCommand(inputs, outputs) verifyAgreeCommand(inputs, outputs)
@ -616,7 +616,7 @@ class InterestRateSwap : Contract {
override val oracleType: ServiceType override val oracleType: ServiceType
get() = NodeInterestRates.Oracle.type get() = NodeInterestRates.Oracle.type
override val ref = common.tradeID val ref: String get() = linearId.externalId ?: ""
override val participants: List<AbstractParty> override val participants: List<AbstractParty>
get() = listOf(fixedLeg.fixedRatePayer, floatingLeg.floatingRatePayer) get() = listOf(fixedLeg.fixedRatePayer, floatingLeg.floatingRatePayer)

2
samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/contracts/IRSState.kt
View File

@ -19,7 +19,7 @@ data class IRSState(val swap: SwapData,
val seller: AbstractParty, val seller: AbstractParty,
override val contract: OGTrade, override val contract: OGTrade,
override val linearId: UniqueIdentifier = UniqueIdentifier(swap.id.first + swap.id.second)) : DealState { override val linearId: UniqueIdentifier = UniqueIdentifier(swap.id.first + swap.id.second)) : DealState {
override val ref: String = linearId.externalId!! // Same as the constructor for UniqueIdentified val ref: String get() = linearId.externalId!! // Same as the constructor for UniqueIdentified
override val participants: List<AbstractParty> get() = listOf(buyer, seller) override val participants: List<AbstractParty> get() = listOf(buyer, seller)
override fun isRelevant(ourKeys: Set<PublicKey>): Boolean { override fun isRelevant(ourKeys: Set<PublicKey>): Boolean {

2
samples/simm-valuation-demo/src/main/kotlin/net/corda/vega/contracts/PortfolioState.kt
View File

@ -29,7 +29,7 @@ data class PortfolioState(val portfolio: List<StateRef>,
data class Update(val portfolio: List<StateRef>? = null, val valuation: PortfolioValuation? = null) data class Update(val portfolio: List<StateRef>? = null, val valuation: PortfolioValuation? = null)
override val participants: List<AbstractParty> get() = _parties.toList() override val participants: List<AbstractParty> get() = _parties.toList()
override val ref: String = linearId.toString() val ref: String get() = linearId.toString()
val valuer: AbstractParty get() = participants[0] val valuer: AbstractParty get() = participants[0]
override fun nextScheduledActivity(thisStateRef: StateRef, flowLogicRefFactory: FlowLogicRefFactory): ScheduledActivity { override fun nextScheduledActivity(thisStateRef: StateRef, flowLogicRefFactory: FlowLogicRefFactory): ScheduledActivity {

14
test-utils/src/main/kotlin/net/corda/testing/contracts/DummyDealContract.kt
View File

@ -21,11 +21,14 @@ class DummyDealContract : Contract {
override fun verify(tx: LedgerTransaction) {} override fun verify(tx: LedgerTransaction) {}
data class State( data class State(
override val contract: Contract = DummyDealContract(), override val contract: Contract,
override val participants: List<AbstractParty> = listOf(), override val participants: List<AbstractParty>,
override val linearId: UniqueIdentifier = UniqueIdentifier(), override val linearId: UniqueIdentifier) : DealState, QueryableState
override val ref: String) : DealState, QueryableState
{ {
constructor(contract: Contract = DummyDealContract(),
participants: List<AbstractParty> = listOf(),
ref: String) : this(contract, participants, UniqueIdentifier(ref))
override fun isRelevant(ourKeys: Set<PublicKey>): Boolean { override fun isRelevant(ourKeys: Set<PublicKey>): Boolean {
return participants.any { it.owningKey.containsAny(ourKeys) } return participants.any { it.owningKey.containsAny(ourKeys) }
} }
@ -39,8 +42,7 @@ class DummyDealContract : Contract {
override fun generateMappedObject(schema: MappedSchema): PersistentState { override fun generateMappedObject(schema: MappedSchema): PersistentState {
return when (schema) { return when (schema) {
is DummyDealStateSchemaV1 -> DummyDealStateSchemaV1.PersistentDummyDealState( is DummyDealStateSchemaV1 -> DummyDealStateSchemaV1.PersistentDummyDealState(
uid = linearId, uid = linearId
dealReference = ref
) )
else -> throw IllegalArgumentException("Unrecognised schema $schema") else -> throw IllegalArgumentException("Unrecognised schema $schema")
} }

5
test-utils/src/main/kotlin/net/corda/testing/schemas/DummyDealStateSchemaV1.kt
View File

@ -3,7 +3,6 @@ package net.corda.testing.schemas
import net.corda.core.contracts.UniqueIdentifier import net.corda.core.contracts.UniqueIdentifier
import net.corda.core.schemas.CommonSchemaV1 import net.corda.core.schemas.CommonSchemaV1
import net.corda.core.schemas.MappedSchema import net.corda.core.schemas.MappedSchema
import javax.persistence.Column
import javax.persistence.Entity import javax.persistence.Entity
import javax.persistence.Table import javax.persistence.Table
import javax.persistence.Transient import javax.persistence.Transient
@ -21,10 +20,6 @@ object DummyDealStateSchemaV1 : MappedSchema(schemaFamily = DummyDealStateSchema
@Entity @Entity
@Table(name = "dummy_deal_states") @Table(name = "dummy_deal_states")
class PersistentDummyDealState( class PersistentDummyDealState(
@Column(name = "deal_reference")
var dealReference: String,
/** parent attributes */ /** parent attributes */
@Transient @Transient
val uid: UniqueIdentifier val uid: UniqueIdentifier