public string SendCreateTransactionToDataBase <A, M>(AssetSaved <A> asset, MetaDataSaved <M> metaData, string privateSignKey)
{
var signPrivateKey = EncryptionService.getSignKeyFromPrivate(privateSignKey);
var transaction = BigchainDbTransactionBuilder <AssetSaved <A>, MetaDataSaved <M> >
.init()
.addAssets(asset)
.addMetaData(metaData)
.operation(Operations.CREATE)
.buildAndSignOnly(signPrivateKey.PublicKey, signPrivateKey);
var createTransaction = TransactionsApi <AssetSaved <A>, MetaDataSaved <M> > .sendTransactionAsync(transaction).GetAwaiter().GetResult();
return(createTransaction.Data.Id);
}
public IActionResult SignUp(mltSignUpViewModel mltSignUpViewModel)
{
string signPrivateKey = null, agreePrivateKey = null, signPublicKey = null, agreePublicKey = null;
Assets <UserCredAssetData> userAsset = _bigChainDbService.GetUserAssetFromTypeID(AssetType.Doctor, mltSignUpViewModel.CSMLSID);
if (userAsset != null)
{
ModelState.AddModelError("", "A Doctor profile with that MINC already exists");
return(View(mltSignUpViewModel));
}
var passphrase = mltSignUpViewModel.MLTKeyWord;
var password = mltSignUpViewModel.Password;
EncryptionService.getNewBlockchainUser(out signPrivateKey, out signPublicKey, out agreePrivateKey, out agreePublicKey);
var userAssetData = new UserCredAssetData
{
FirstName = mltSignUpViewModel.FirstName,
LastName = mltSignUpViewModel.LastName,
ID = mltSignUpViewModel.CSMLSID,
Email = mltSignUpViewModel.Email,
PrivateKeys = EncryptionService.encryptPrivateKeys(mltSignUpViewModel.CSMLSID, passphrase, signPrivateKey, agreePrivateKey),
DateOfRecord = DateTime.Now,
SignPublicKey = signPublicKey,
AgreePublicKey = agreePublicKey,
FingerprintData = new List <string>(),
};
var userMetadata = new UserCredMetadata
{
hashedPassword = EncryptionService.hashPassword(password)
};
var asset = new AssetSaved <UserCredAssetData>
{
Type = AssetType.MLT,
Data = userAssetData,
RandomId = _random.Next(0, 100000)
};
var metadata = new MetaDataSaved <UserCredMetadata>
{
data = userMetadata
};
_bigChainDbService.SendCreateTransactionToDataBase(asset, metadata, signPrivateKey);
return(RedirectToAction("Login"));
}
public IActionResult UploadResult(UploadResultViewModel uploadResultViewModel)
{
// Get's the Doctor's information for current session
ViewBag.DoctorName = HttpContext.Session.GetString(Globals.currentUserName);
var oldViewModel = JsonConvert.DeserializeObject <UploadResultViewModel>(TempData["viewModel"] as string);
uploadResultViewModel.TestData = oldViewModel.TestData;
uploadResultViewModel.PatientAsset = oldViewModel.PatientAsset;
uploadResultViewModel.PatientMetadata = oldViewModel.PatientMetadata;
TempData["viewModel"] = JsonConvert.SerializeObject(uploadResultViewModel);
if (!ModelState.IsValid)
{
return(View(uploadResultViewModel));
}
var doctorSignPrivateKey = HttpContext.Session.GetString(Globals.currentDSPriK);
var doctorAgreePrivateKey = HttpContext.Session.GetString(Globals.currentDAPriK);
var doctorSignPublicKey = EncryptionService.getSignPublicKeyStringFromPrivate(doctorSignPrivateKey);
var patientSignPublicKey = HttpContext.Session.GetString(Globals.currentPSPubK);
var transID = uploadResultViewModel.TestData.transID;
var testRequisition = _bigChainDbService.GetMetaDataAndAssetFromTransactionId <string, double>(transID);
//Check MLT has access to upload data
if (testRequisition.metadata.AccessList.Keys.Contains(doctorSignPublicKey))
{
//Get hash key for requisition. We will use the same key for result
var hashedKey = testRequisition.metadata.AccessList[doctorSignPublicKey];
var dataDecryptionKey = EncryptionService.getDecryptedEncryptionKey(hashedKey, doctorAgreePrivateKey);
if (uploadResultViewModel.ResultFile != null)
{
var file = uploadResultViewModel.ResultFile;
string base64FileString = "";
// Convert "file" into base64 string "base64FileString" to save into database
using (var ms = new MemoryStream())
{
file.CopyTo(ms);
var fileBytes = ms.ToArray();
base64FileString = Convert.ToBase64String(fileBytes);
}
//encrypt file data and save to ipfs
var encryptFileData = EncryptionService.getEncryptedAssetDataKey(base64FileString, dataDecryptionKey);
var cid = _bigChainDbService.UploadTextToIPFS(encryptFileData);
var resultFile = new FileData()
{
Data = cid,
Type = file.ContentType,
Extension = file.ContentType.Split('/').Last(),
Name = file.FileName
};
//Encrypt the file using the same key
var encryptedFile = EncryptionService.getEncryptedAssetDataKey(JsonConvert.SerializeObject(resultFile), dataDecryptionKey);
var asset = new AssetSaved <TestResultAsset>
{
Data = new TestResultAsset
{
RequisitionAssetID = testRequisition.id,
EncryptedResult = encryptedFile
},
RandomId = _random.Next(0, 100000),
Type = AssetType.TestResult
};
//Access is managed by requisition asset
var metadata = new MetaDataSaved <double>();
metadata.AccessList = new Dictionary <string, string>();
_bigChainDbService.SendCreateTransferTransactionToDataBase(asset, metadata, doctorSignPrivateKey, patientSignPublicKey);
return(RedirectToAction("PatientRecords"));
}
else
{
ModelState.AddModelError("", "Missing test result file.");
return(View(uploadResultViewModel));
}
}
else
{
ModelState.AddModelError("", "You do not have permission to upload test result.");
return(View(uploadResultViewModel));
}
}
public IActionResult AddNewPatientRecord(AddNewPatientRecordViewModel addNewPatientRecordViewModel)
{
ViewBag.DoctorName = HttpContext.Session.GetString(Globals.currentUserName);
if (!string.IsNullOrEmpty(addNewPatientRecordViewModel.DoctorsNote.PurposeOfVisit))
{
var noteViewModel = addNewPatientRecordViewModel.DoctorsNote;
var doctorNote = new DoctorNote
{
PurposeOfVisit = noteViewModel.PurposeOfVisit,
Description = noteViewModel.Description,
FinalDiagnosis = noteViewModel.FinalDiagnosis,
FurtherInstructions = noteViewModel.FurtherInstructions,
DoctorName = HttpContext.Session.GetString(Globals.currentUserName),
DoctorMinsc = HttpContext.Session.GetString(Globals.currentUserID),
DateOfRecord = DateTime.Now
};
string encryptionKey;
var encryptedData = EncryptionService.getEncryptedAssetData(JsonConvert.SerializeObject(doctorNote), out encryptionKey);
var asset = new AssetSaved <string>
{
Data = encryptedData,
RandomId = _random.Next(0, 100000),
Type = AssetType.DoctorNote
};
var metadata = new MetaDataSaved <double>();
metadata.AccessList = new Dictionary <string, string>();
//store the data encryption key in metadata encrypted with sender and reciever agree key
var doctorSignPrivateKey = HttpContext.Session.GetString(Globals.currentDSPriK);
var doctorAgreePrivateKey = HttpContext.Session.GetString(Globals.currentDAPriK);
var patientAgreePublicKey = HttpContext.Session.GetString(Globals.currentPAPubK);
var patientSignPublicKey = HttpContext.Session.GetString(Globals.currentPSPubK);
var doctorSignPublicKey = EncryptionService.getSignPublicKeyStringFromPrivate(doctorSignPrivateKey);
var doctorAgreePublicKey = EncryptionService.getAgreePublicKeyStringFromPrivate(doctorAgreePrivateKey);
metadata.AccessList[doctorSignPublicKey] =
EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, doctorAgreePublicKey);
metadata.AccessList[patientSignPublicKey] =
EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, patientAgreePublicKey);
_bigChainDbService.SendCreateTransferTransactionToDataBase <string, double>(asset, metadata, doctorSignPrivateKey, patientSignPublicKey);
}
if (!string.IsNullOrEmpty(addNewPatientRecordViewModel.Prescription.DrugName))
{
var prescriptionViewModel = addNewPatientRecordViewModel.Prescription;
var prescription = new Prescription
{
PrescribingDate = prescriptionViewModel.PrescribingDate,
Superscription = prescriptionViewModel.Superscription,
DrugName = prescriptionViewModel.DrugName,
Dosage = prescriptionViewModel.Dosage,
//StartDate = prescriptionViewModel.StartDate,
EndDate = prescriptionViewModel.EndDate,
Refill = prescriptionViewModel.Refill,
Substitution = prescriptionViewModel.Substitution,
DoctorName = HttpContext.Session.GetString(Globals.currentUserName),
DoctorMinsc = HttpContext.Session.GetString(Globals.currentUserID),
DirectionForUse = prescriptionViewModel.DirectionForUse
};
string encryptionKey;
var encryptedData = EncryptionService.getEncryptedAssetData(JsonConvert.SerializeObject(prescription), out encryptionKey);
var asset = new AssetSaved <string>
{
Data = encryptedData,
RandomId = _random.Next(0, 100000),
Type = AssetType.Prescription
};
var metadata = new MetaDataSaved <PrescriptionMetadata>
{
AccessList = new Dictionary <string, string>(),
data = new PrescriptionMetadata
{
RefillRemaining = prescription.Refill,
LastIssueQty = -1
}
};
//store the data encryption key in metadata encrypted with sender and reciever agree key
var doctorSignPrivateKey = HttpContext.Session.GetString(Globals.currentDSPriK);
var doctorAgreePrivateKey = HttpContext.Session.GetString(Globals.currentDAPriK);
var patientAgreePublicKey = HttpContext.Session.GetString(Globals.currentPAPubK);
var patientSignPublicKey = HttpContext.Session.GetString(Globals.currentPSPubK);
var doctorSignPublicKey = EncryptionService.getSignPublicKeyStringFromPrivate(doctorSignPrivateKey);
var doctorAgreePublicKey = EncryptionService.getAgreePublicKeyStringFromPrivate(doctorAgreePrivateKey);
metadata.AccessList[doctorSignPublicKey] =
EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, doctorAgreePublicKey);
metadata.AccessList[patientSignPublicKey] =
EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, patientAgreePublicKey);
_bigChainDbService.SendCreateTransferTransactionToDataBase <string, PrescriptionMetadata>(asset, metadata, doctorSignPrivateKey, patientSignPublicKey);
}
//There is a test result that exists
if (!string.IsNullOrEmpty(addNewPatientRecordViewModel.TestRequisition.ReasonForTest))
{
//File exists
if (addNewPatientRecordViewModel.TestRequisition.AttachedFile != null)
{
var file = addNewPatientRecordViewModel.TestRequisition.AttachedFile;
string base64FileString = "";
// Convert "file" into base64 string "base64FileString" to save into database
using (var ms = new MemoryStream())
{
file.CopyTo(ms);
var fileBytes = ms.ToArray();
base64FileString = Convert.ToBase64String(fileBytes);
}
//encrypt file and store in ipfs
var encryptionKey = EncryptionService.getNewAESEncryptionKey();
var encryptedFile = EncryptionService.getEncryptedAssetDataKey(base64FileString, encryptionKey);
var id = _bigChainDbService.UploadTextToIPFS(encryptedFile);
var testRequisition = new TestRequisitionAsset
{
AttachedFile = new FileData
{
Data = id,
Type = file.ContentType,
Extension = file.ContentType.Split('/').Last(),
Name = file.FileName
},
ReasonForTest = addNewPatientRecordViewModel.TestRequisition.ReasonForTest,
TestType = addNewPatientRecordViewModel.TestRequisition.TestType,
DateOrdered = DateTime.Now
};
var encryptedData = EncryptionService.getEncryptedAssetDataKey(JsonConvert.SerializeObject(testRequisition), encryptionKey);
var asset = new AssetSaved <string>
{
Data = encryptedData,
RandomId = _random.Next(0, 100000),
Type = AssetType.TestRequisition
};
var metadata = new MetaDataSaved <double>();
metadata.AccessList = new Dictionary <string, string>();
//store the data encryption key in metadata encrypted with sender and reciever agree key
var doctorSignPrivateKey = HttpContext.Session.GetString(Globals.currentDSPriK);
var doctorAgreePrivateKey = HttpContext.Session.GetString(Globals.currentDAPriK);
var patientAgreePublicKey = HttpContext.Session.GetString(Globals.currentPAPubK);
var patientSignPublicKey = HttpContext.Session.GetString(Globals.currentPSPubK);
var doctorSignPublicKey = EncryptionService.getSignPublicKeyStringFromPrivate(doctorSignPrivateKey);
var doctorAgreePublicKey = EncryptionService.getAgreePublicKeyStringFromPrivate(doctorAgreePrivateKey);
metadata.AccessList[doctorSignPublicKey] =
EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, doctorAgreePublicKey);
metadata.AccessList[patientSignPublicKey] =
EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, patientAgreePublicKey);
_bigChainDbService.SendCreateTransferTransactionToDataBase <string, double>(asset, metadata, doctorSignPrivateKey, patientSignPublicKey);
}
}
return(RedirectToAction("PatientOverview"));
}
public IActionResult PatientSignUp(PatientSignUpViewModel patientSignUpViewModel)
{
// Description: Registers a patient up for a MedNet account
ViewBag.DoctorName = HttpContext.Session.GetString(Globals.currentUserName);
string signPrivateKey = null, agreePrivateKey = null, signPublicKey = null, agreePublicKey = null;
Assets <PatientCredAssetData> userAsset = _bigChainDbService.GetPatientAssetFromID(patientSignUpViewModel.PHN);
// Check if PHN is already in use
if (userAsset != null)
{
ModelState.AddModelError("", "A Patient profile with that PHN already exists");
return(View(patientSignUpViewModel));
}
// Register fingerprint information
int numScans = 5;
List <Image> fpList = FingerprintService.authenticateFP("24.84.225.22", numScans);
List <byte[]> fpdb = new List <byte[]>();
if (fpList.Count > numScans)
{
ModelState.AddModelError("", "Something went wrong with the fingerprint scan, try again.");
return(View(patientSignUpViewModel));
}
// Parse the input data for user registration
var passphrase = patientSignUpViewModel.KeyWord;
var password = patientSignUpViewModel.Password;
// Encrypt fingerprint data
List <string> encrList = new List <string>();
foreach (var fp in fpList)
{
byte[] fpByte = FingerprintService.imgToByte(fp);
string encrStr = EncryptionService.encryptFingerprintData(patientSignUpViewModel.PHN, passphrase, fpByte);
encrList.Add(encrStr);
}
// Create a user for the Blockchain
EncryptionService.getNewBlockchainUser(out signPrivateKey, out signPublicKey, out agreePrivateKey, out agreePublicKey);
// Create the user Asset
var userAssetData = new PatientCredAssetData
{
ID = patientSignUpViewModel.PHN,
DateOfBirth = patientSignUpViewModel.DateOfBirth,
PrivateKeys = EncryptionService.encryptPrivateKeys(patientSignUpViewModel.PHN, passphrase, signPrivateKey, agreePrivateKey),
DateOfRecord = DateTime.Now,
SignPublicKey = signPublicKey,
AgreePublicKey = agreePublicKey,
FingerprintData = encrList,
};
// Encrypt the user's password in the metadata
var userMetadata = new PatientCredMetadata
{
FirstName = patientSignUpViewModel.FirstName,
LastName = patientSignUpViewModel.LastName,
Email = patientSignUpViewModel.Email,
hashedPassword = EncryptionService.hashPassword(password)
};
// Save the user Asset and Metadata
var asset = new AssetSaved <PatientCredAssetData>
{
Type = AssetType.Patient,
Data = userAssetData,
RandomId = _random.Next(0, 100000)
};
var metadata = new MetaDataSaved <PatientCredMetadata>
{
data = userMetadata
};
// Send the user's information to the Blockchain database
_bigChainDbService.SendCreateTransactionToDataBase(asset, metadata, signPrivateKey);
return(RedirectToAction("PatientLookUp"));
}