fork download

copy

class PolicyContract : Contract {
 
    companion object {
        @JvmStatic
        val POLICY_CONTRACT_ID = "com.example.contract.PolicyContract"
    }
 
    override fun verify(tx: LedgerTransaction) {
        val commandCreate = tx.commands.requireSingleCommand<Commands.Create>()
        requireThat {
            "No inputs should be consumed when creating an Policy ." using (tx.inputs.isEmpty())
            //"Only one customer state should be created." using (tx.outputs.size == 1)
            val out = tx.outputsOfType<PolicyState>().single()
            "The insurer and the airline cannot be the same entity." using (out.insurer != out.airline)
            "All of the participants must be signers." using (commandCreate.signers.containsAll(out.participants.map { it.owningKey }))
 
            // IOU-specific constraints.
            "The Policy holders SSN value must not be an empty String." using (out.ssn.isNotEmpty() )
 
            "The Policy Number should not be null or empty." using (out.policyNumber.isNotEmpty() )
        }
 
    }
 
 
    interface Commands : CommandData {
        class Create : Commands
 
    }
}

prog.kt:1:24: error: unresolved reference: Contract
class PolicyContract : Contract {
                       ^
prog.kt:8:5: error: 'verify' overrides nothing
    override fun verify(tx: LedgerTransaction) {
    ^
prog.kt:8:29: error: unresolved reference: LedgerTransaction
    override fun verify(tx: LedgerTransaction) {
                            ^
prog.kt:10:9: error: unresolved reference: requireThat
        requireThat {
        ^
prog.kt:11:70: error: unresolved reference: using
            "No inputs should be consumed when creating an Policy ." using (tx.inputs.isEmpty())
                                                                     ^
prog.kt:13:40: error: unresolved reference: PolicyState
            val out = tx.outputsOfType<PolicyState>().single()
                                       ^
prog.kt:14:70: error: unresolved reference: using
            "The insurer and the airline cannot be the same entity." using (out.insurer != out.airline)
                                                                     ^
prog.kt:15:56: error: unresolved reference: using
            "All of the participants must be signers." using (commandCreate.signers.containsAll(out.participants.map { it.owningKey }))
                                                       ^
prog.kt:15:120: error: unresolved reference: it
            "All of the participants must be signers." using (commandCreate.signers.containsAll(out.participants.map { it.owningKey }))
                                                                                                                       ^
prog.kt:18:73: error: unresolved reference: using
            "The Policy holders SSN value must not be an empty String." using (out.ssn.isNotEmpty() )
                                                                        ^
prog.kt:20:62: error: unresolved reference: using
            "The Policy Number should not be null or empty." using (out.policyNumber.isNotEmpty() )
                                                             ^
prog.kt:26:26: error: unresolved reference: CommandData
    interface Commands : CommandData {
                         ^

Standard output is empty