public async Task createEHRCredentials(string schemaJson)
{
string[] doctors = { "Doctor1", "Doctor2", "Doctor3" };
string[] patients = { "Patient1", "Patient2" };
foreach (string doctor in doctors)
{
await initialize(doctor);
string credDefDefinition =
await CredDefFacilitator.getCredDef("EHR", d_wallet);
JObject o = JObject.Parse(credDefDefinition);
string credDefId = o["id"].ToString();
// create cred def offer to share with trusted parties
string credOffer = await d_wallet.createCredentialOffer(credDefId);
string schemaAttributes =
"[\"importance_level\", \"issuer\", \"data_value\", \"data_type\"]";
string schemaValues = "[\"1\", \"" + doctor + "\", \"data sample\", \"type sample\"]";
foreach (string patient in patients)
{
await issueCredential(doctor, patient, "EHR" + doctor + ":" + patient,
schemaAttributes, schemaValues, schemaJson,
credOffer, credDefDefinition);
}
}
}
public async Task createDoctorWallets(string issuer, string issuerDid)
{
var exists = await d_wallet.exists("Doctor1");
if (exists)
{
Console.WriteLine("Doctor wallets already exists.");
return;
}
await createAndPublishWallet(issuer, issuerDid, "Doctor1",
"0000000000000000000000000Doctor1");
await initialize("Doctor1");
await CredDefFacilitator.createPatientCredentialDefinitions(d_ledger);
await createAndPublishWallet(issuer, issuerDid, "Doctor2",
"0000000000000000000000000Doctor2");
await initialize("Doctor2");
await CredDefFacilitator.createPatientCredentialDefinitions(d_ledger);
await createAndPublishWallet(issuer, issuerDid, "Doctor3",
"0000000000000000000000000Doctor3");
await initialize("Doctor3");
await CredDefFacilitator.createPatientCredentialDefinitions(d_ledger);
}
public async Task createEHRWallets(string issuer, string issuerDid)
{
await createAndPublishWallet(issuer, issuerDid, "Patient1",
"000000000000000000000000Patient1");
await initialize("Patient1");
await CredDefFacilitator.createPatientCredentialDefinitions(d_ledger);
await createAndPublishWallet(issuer, issuerDid, "Patient2",
"000000000000000000000000Patient2");
await initialize("Patient2");
await CredDefFacilitator.createPatientCredentialDefinitions(d_ledger);
await createAndPublishWallet(issuer, issuerDid, "TrustedParty1",
"0000000000000000000TrustedParty1");
await createAndPublishWallet(issuer, issuerDid, "TrustedParty2",
"0000000000000000000TrustedParty2");
await createAndPublishWallet(issuer, issuerDid, "TrustedParty3",
"0000000000000000000TrustedParty3");
await createAndPublishWallet(issuer, issuerDid, "TrustedParty4",
"0000000000000000000TrustedParty4");
await createAndPublishWallet(issuer, issuerDid, "TrustedParty5",
"0000000000000000000TrustedParty5");
}
public async Task setupSharedSecretCredentials(string issuer,
string schemaJson, string schemaJson2)
{
await initialize(issuer);
// create creddef in patient wallet
string credDefDefinition =
await CredDefFacilitator.getCredDef("ESS", d_wallet);
string credDefDefinition2 =
await CredDefFacilitator.getCredDef("ETP", d_wallet);
JObject o = JObject.Parse(credDefDefinition);
string credDefId = o["id"].ToString();
o = JObject.Parse(credDefDefinition2);
string credDefId2 = o["id"].ToString();
// create cred def offer to share with trusted parties
string credOffer = await d_wallet.createCredentialOffer(credDefId);
string credOffer2 = await d_wallet.createCredentialOffer(credDefId2);
// create shared secrets
string secretsJson =
await d_wallet.createEmergencySharedSecrets(3, 5);
// schemaAttributes
string schemaAttributes =
"[\"secret_owner\", \"secret_issuer\", \"secret\"]";
string schemaAttributes2 =
"[\"secret_owner\", \"secret_issuer\", \"min\", \"total\"]";
string[] trustees = { "TrustedParty1", "TrustedParty2", "TrustedParty3"
, "TrustedParty4", "TrustedParty5" };
for (int idx = 0; idx < 5; idx++)
{
o = (JObject)JArray.Parse(secretsJson)[idx];
string schemaValues =
"[\"" + trustees[idx] + "\", \"" + issuer + "\", \"" +
o["id"] + "\"]";
string schemaValues2 =
"[\"" + trustees[idx] + "\", \"" + issuer + "\", \"" +
3 + "\", \"" + 5 + "\"]";
// share secret via credential
await issueCredential(issuer, trustees[idx], "ESS-" + issuer,
schemaAttributes, schemaValues, schemaJson,
credOffer, credDefDefinition);
// share with Gov-Health-Department who has a secret of mine
await issueCredential(issuer, "Gov-Health-Department",
"ETP-" + issuer + ":" + trustees[idx],
schemaAttributes2, schemaValues2, schemaJson2,
credOffer2, credDefDefinition2);
// mark secret as shared
await initialize(issuer);
await d_wallet.updateRecordTag(
"shared-secret",
o["id"].ToString(),
"{\"is_shared\": \"1\"}");
}
await d_wallet.close();
}
public static async Task run()
{
var res = "";
while (true)
{
setInputLine();
var input = Console.ReadLine();
input = input.Trim();
try
{
switch (input)
{
case "exit":
d_prompt.exitMessage();
return;
case "pool create":
res = await d_pool.create(d_prompt.poolName(),
d_prompt.poolTransactionsGenesis());
break;
case "pool list":
res = await d_pool.list();
break;
case "pool connect":
await d_pool.connect(d_prompt.poolName());
break;
case "wallet open":
res = await d_wallet.open(
d_prompt.issuerWalletName(),
d_prompt.walletMasterKey());
break;
case "wallet create":
await d_wallet.create(d_prompt.issuerWalletName(),
d_prompt.walletMasterKey());
break;
case "wallet close":
res = await d_wallet.close();
break;
case "wallet list":
IOFacilitator.listDirectories("/wallet");
break;
case "did list":
requiredWalletCheck();
res = await d_wallet.listDids();
break;
case "did create":
requiredWalletCheck();
await d_wallet.createDid(d_prompt.didSeed(),
d_prompt.didMetaDataJson());
break;
case "did activate":
requiredWalletCheck();
d_wallet.setActiveDid(d_prompt.myDid());
break;
case "ledger send initial nym":
requiredWalletCheck();
requiredDidCheck();
requiredPoolCheck();
await d_ledger.sendNymRequest(
d_prompt.nymDid(),
d_prompt.nymVerkey(),
d_prompt.nymAlias(),
d_prompt.nymRole());
break;
case "schema create":
requiredWalletCheck();
requiredDidCheck();
requiredPoolCheck();
res = await d_ledger.createSchema(
d_prompt.schemaName(),
d_prompt.schemaVersion(),
d_prompt.schemaAttributes());
break;
case "schema get":
requiredWalletCheck();
requiredDidCheck();
requiredPoolCheck();
res = await d_ledger.getSchema(
d_prompt.submitterDid(),
d_prompt.schemaId());
break;
case "government schema list":
GovernmentSchemasModel govModel =
GovernmentSchemasModel.importFromJsonFile();
res = govModel.toJson();
break;
case "schema list":
requiredWalletCheck();
res = await d_wallet.listSchemas();
break;
case "master secret create":
requiredWalletCheck();
res = await d_wallet.createMasterSecret(
d_prompt.secretId());
break;
case "credential definition list":
requiredWalletCheck();
requiredDidCheck();
res = await d_wallet.listCredDefs();
break;
case "credential definition get":
requiredWalletCheck();
res = await CredDefFacilitator.getCredDef(
d_prompt.credDefTag(), d_wallet);
break;
case "credential definition create":
requiredWalletCheck();
requiredDidCheck();
requiredPoolCheck();
res = await d_ledger.createCredDef(
d_prompt.schemaJson(),
d_prompt.credDefTag());
break;
case "credential definitions patient create":
requiredWalletCheck();
requiredDidCheck();
requiredPoolCheck();
await CredDefFacilitator.
createPatientCredentialDefinitions(
d_ledger);
res = await d_wallet.listCredDefs();
break;
case "credential offer create":
requiredWalletCheck();
res = await d_wallet.createCredentialOffer(
d_prompt.credDefId());
break;
case "credential request create":
requiredWalletCheck();
requiredDidCheck();
res = await d_wallet.createCredentialRequest(
d_prompt.credOfferJson(),
d_prompt.credDefJson(),
d_prompt.secretId());
break;
case "credential create":
requiredWalletCheck();
res = await d_wallet.createCredential(
d_prompt.credOfferJson(),
d_prompt.credReqJson(),
CredentialFacilitator.generateCredValueJson(
d_prompt.schemaAttributes(),
d_prompt.credValues())
);
break;
case "credential store":
requiredWalletCheck();
res = await d_wallet.storeCredential(
d_prompt.credReqMetaJson(),
d_prompt.credJson(),
d_prompt.credDefJson());
break;
case "credential list":
requiredWalletCheck();
res = await d_wallet.getCredentials("{}");
break;
case "credential get":
requiredWalletCheck();
res = await d_wallet.getCredentials(
d_prompt.walletQuery());
break;
case "emergency key list":
requiredWalletCheck();
res = await d_wallet.listSharedSecrets();
break;
case "emergency key list unused":
requiredWalletCheck();
res = await d_wallet.listSharedSecrets(
"{\"is_shared\": \"0\"}");
break;
case "wallet backup shared secret create":
requiredWalletCheck();
res = await d_wallet.createWalletBackupSharedSecrets(
d_prompt.sharedSecretMinimum(),
d_prompt.sharedSecretTotal());
break;
case "shared secret reconstruct":
res = SecretSharingFacilitator.combineSharedSecrets(
d_prompt.readSharedSecrets());
break;
case "emergency key mark shared":
requiredWalletCheck();
await d_wallet.updateRecordTag(
"shared-secret",
d_prompt.recordId(),
"{\"~is_shared\": \"1\"}");
break;
case "emergency key provide":
res = await d_wallet.holderSharedSecretProvide(
d_prompt.proofJson(),
d_prompt.issuerWalletName());
break;
case "trusted party list":
requiredWalletCheck();
res = await d_wallet.getTrustedParties(
d_prompt.proofJson(),
d_prompt.issuerWalletName());
break;
case "offline emergency secret obtain":
res = await OfflineSecretController.obtain(
d_prompt.proofJson(),
d_prompt.issuerWalletName());
break;
case "medical dossier backup":
requiredWalletCheck();
if (ensurer("The existing emergency medical dossier will be deleted as will the emergency keys. Are you sure you want to continu?(y/n)"))
{
res = await d_wallet.createEmergencySharedSecrets(
d_prompt.sharedSecretMinimum(),
d_prompt.sharedSecretTotal());
}
break;
case "medical dossier list":
res = await d_wallet.getEHRCredentials();
break;
case "emergency medical dossier download":
EHRBackupModel model =
EHRBackupModel.importFromJson(
d_prompt.emergencyEHRJSON());
res = await model.downloadEmergencyEHR();
break;
case "doctor proof request":
res = DoctorProofFacilitator.getProofRequest();
break;
case "doctor proof create":
requiredWalletCheck();
res = await DoctorProofFacilitator.
createDoctorProof(d_wallet.getOpenWallet());
break;
case "doctor proof verify":
bool result =
await DoctorProofFacilitator.verifyDoctorProof(
d_prompt.proofJson());
res = result.ToString();
break;
case "wallet export local":
requiredWalletCheck();
res = await d_wallet.walletExportLocal(
d_prompt.walletPath(),
d_prompt.walletExportKey());
break;
case "wallet export ipfs":
requiredWalletCheck();
res = await d_wallet.walletExportIpfs(
d_prompt.walletExportKey(),
d_prompt.walletMasterKey());
break;
case "wallet import local":
res = await d_wallet.walletImportLocal(
d_prompt.walletIdentifier(),
d_prompt.walletPath(),
d_prompt.walletMasterKey(),
d_prompt.walletExportKey());
break;
case "wallet import ipfs":
res = await d_wallet.walletImportIpfs(
d_prompt.walletIdentifier(),
d_prompt.walletJsonConfig());
break;
case "wallet record add":
requiredWalletCheck();
res = await d_wallet.addRecord(
d_prompt.recordType(),
d_prompt.recordId(),
d_prompt.recordValue(),
d_prompt.recordTagsJson());
break;
case "wallet record get":
requiredWalletCheck();
res = await d_wallet.getRecord(
d_prompt.recordType(),
d_prompt.walletQuery(),
d_prompt.walletOptions());
break;
case "wallet record delete":
requiredWalletCheck();
await d_wallet.deleteRecord(
d_prompt.recordType(),
d_prompt.recordId());
break;
case "wallet record update tag":
requiredWalletCheck();
await d_wallet.updateRecordTag(
d_prompt.recordType(),
d_prompt.recordId(),
d_prompt.recordTagsJson());
break;
case "EHR environment setup":
requiredPoolCheck();
if (ensurer("Are you sure you want to setup the environment?"))
{
await d_setup.setupEHREnvironment();
}
break;
case "help":
d_prompt.helpOptions();
break;
default:
d_prompt.inputUnrecognized();
break;
}
}
catch (Exception e)
{
res = "An error happened:" + e.Message;
}
if (res != "")
{
Console.WriteLine(res);
}
res = "";
}
}
