package th.co.jventures.ddlp.cordapp.flows
import co.paralleluniverse.fibers.Suspendable
import net.corda.confidential.IdentitySyncFlow
import net.corda.core.contracts.Command
import net.corda.core.contracts.UniqueIdentifier
import net.corda.core.contracts.requireThat
import net.corda.core.flows.*
import net.corda.core.identity.Party
import net.corda.core.transactions.SignedTransaction
import net.corda.core.transactions.TransactionBuilder
import net.corda.core.utilities.ProgressTracker
import net.corda.core.utilities.unwrap
import th.co.jventures.ddlp.cordapp.contracts.CustomerContract
import th.co.jventures.ddlp.cordapp.core.commons.CordappConstants
import th.co.jventures.ddlp.cordapp.dto.CustomerIssueData
import th.co.jventures.ddlp.cordapp.services.CustomerService
import th.co.jventures.ddlp.cordapp.states.Address
import th.co.jventures.ddlp.cordapp.states.Consent
import th.co.jventures.ddlp.cordapp.states.CustomerState
import th.co.jventures.ddlp.cordapp.utils.CordappValidationUtils.Companion.requiredNotWhen
import java.util.*
@InitiatingFlow
@StartableByRPC
class CustomerIssueFlow(private val customerIssueData: CustomerIssueData) : FlowLogic<String>() {
companion object {
object GENERATING_TRANSACTION : ProgressTracker.Step("Generating transaction based on new IOU.")
object VERIFYING_TRANSACTION : ProgressTracker.Step("Verifying contract constraints.")
object SIGNING_TRANSACTION : ProgressTracker.Step("Signing transaction with our private key.")
object GATHERING_SIGS : ProgressTracker.Step("Gathering the counterparty's signature.") {
override fun childProgressTracker() = CollectSignaturesFlow.tracker()
}
object FINALISING_TRANSACTION : ProgressTracker.Step("Obtaining notary signature and recording transaction.") {
override fun childProgressTracker() = FinalityFlow.tracker()
}
fun tracker() = ProgressTracker(
GENERATING_TRANSACTION,
VERIFYING_TRANSACTION,
SIGNING_TRANSACTION,
GATHERING_SIGS,
FINALISING_TRANSACTION
)
}
override val progressTracker = tracker()
@Suspendable
override fun call(): String {
// Obtain a reference to the notary we want to use.
val notary = serviceHub.networkMapCache.notaryIdentities[0]
// Stage 1.
progressTracker.currentStep = GENERATING_TRANSACTION
// Generate an unsigned transaction.
val customerService = serviceHub.cordaService(CustomerService::class.java)
//#################################################################//
val pahNode = serviceHub.networkMapCache.getPeerByLegalName(CordappConstants.Node.PAH) as Party
val participants = listOf(ourIdentity, pahNode)
val customerStateAndRef = customerService.findByIdCardNoAndPartner(idCarNo = customerIssueData.customerData.idCardNo!!, partner = customerIssueData.customerData.partner!!)
//check duplicate customer
requiredNotWhen(customerStateAndRef == null, "Customer already registered")
val addresses = customerIssueData.customerData.addresses?.map { it ->
Address(
seqId = it.seqId,
id = UUID.randomUUID().toString(),
type = it.type,
houseNumber = it.houseNumber,
street = it.street,
subDistrict = it.subDistrict,
district = it.district,
province = it.province,
postalCode = it.postalCode,
countryCode = it.countryCode,
mobile = it.mobile,
telephone = it.telephone
)
}
val consentsArray = customerIssueData.customerData.consents?.map { it ->
Consent(
id = UUID.randomUUID().toString(),
partner = it.partner,
product = it.product,
reference = it.reference,
createDate = it.createDate
)
}
val linearId = UniqueIdentifier()
val customerState = CustomerState(
linearId = linearId,
externalCustomerNo = customerIssueData.customerData.externalCustomerNo!!,
title = customerIssueData.customerData.title!!,
firstName = customerIssueData.customerData.firstName!!,
middleName = customerIssueData.customerData.middleName!!,
lastName = customerIssueData.customerData.lastName!!,
idCardNo = customerIssueData.customerData.idCardNo!!,
email = customerIssueData.customerData.email!!,
partner = customerIssueData.customerData.partner!!,
product = customerIssueData.customerData.product!!,
consents = consentsArray,
status = CordappConstants.CustomerStatus.Active,
addresses = addresses,
participants = participants,
createDate = Date(),
createBy = customerIssueData.customerData.username!!,
changeDate = Date(),
changeBy = customerIssueData.customerData.username!!
)
val txCommand = Command(CustomerContract.Commands.Issue(), customerState.participants.map { it.owningKey })
val txBuilder = TransactionBuilder(notary)
.addOutputState(customerState, CustomerContract.CONTRACT_ID)
.addCommand(txCommand)
//#################################################################//
// Stage 2.
progressTracker.currentStep = VERIFYING_TRANSACTION
// Verify that the transaction is valid.
txBuilder.verify(serviceHub)
// Stage 3.
progressTracker.currentStep = SIGNING_TRANSACTION
// Sign the transaction.
val partSignedTx = serviceHub.signInitialTransaction(txBuilder)
// Stage 4.
progressTracker.currentStep = GATHERING_SIGS
// Send the state to the counterparty, and receive it back with their signature.
val session = (customerState.participants - ourIdentity).map { initiateFlow(it) }
val fullySignedTx = subFlow(CollectSignaturesFlow(partSignedTx, session, GATHERING_SIGS.childProgressTracker()))
// Stage 5.
progressTracker.currentStep = FINALISING_TRANSACTION
// Notarise and record the transaction in both parties' vaults.
subFlow(FinalityFlow(fullySignedTx, FINALISING_TRANSACTION.childProgressTracker()))
return customerState.linearId.toString()
}
}
@InitiatedBy(CustomerIssueFlow::class)
class CustomerIssueFlowResponder(val otherSideSession: FlowSession) : FlowLogic<SignedTransaction>() {// TwoPartyDealFlow.Acceptor(otherSideSession) {
@Suspendable
override fun call(): SignedTransaction {
// val finalTx = super.call()
println("######## START CustomerIssueFlowResponder ########################################################")
println(ourIdentity)
val signTransactionFlow = object : SignTransactionFlow(otherSideSession) {
override fun checkTransaction(stx: SignedTransaction) = requireThat {
// val output = stx.tx.outputs.single().data
//"This must be an CustomerState." using (output is CustomerState)
}
}
val stx = subFlow(ReceiveTransactionFlow(otherSideSession, checkSufficientSignatures = false))
val customerState = stx.tx.outputs.single().data as CustomerState
subFlow(CustomerPAHIssueOrUpdateFlow(customerState))
println("######## END CustomerIssueFlowResponder ########################################################")
return subFlow(signTransactionFlow)
}
}