public UploadResultViewModel Execute(IFormFile xmlFile)
{
UploadResultViewModel result = new UploadResultViewModel();
try
{
if (!validExtensions.Any(e => e.Contains(xmlFile.ContentType)))
{
throw new UploadedFileWrongFormatException(xmlFile.ContentType);
}
using (MemoryStream stream = new MemoryStream())
{
xmlFile.CopyTo(stream);
result = UpdateStore(serializer.Deserialize(stream));
fileCopy.Create(stream, "store_update_", ".xml", "XML", "done_updates");
}
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
result.Message = ex.Message;
result.Succes = false;
}
finally
{
string outcome = result.Succes ? "SUCCESS" : "FAILURE";
logger.LogInformation("External Drugstore was supplied with" + outcome);
}
return(result);
}
public ActionResult UploadResult(int id)
{
var subject = db.Courses.Where(c => c.CourseId == id).SingleOrDefault();
var SubjectRel = db.StudentRegSubjectRelations.Where(c => c.SubjectId == id).ToList();
List <Student> StudentsList = new List <Student>();
var students = db.Students.ToList();
foreach (var item in students)
{
foreach (var item1 in SubjectRel)
{
if (item.StudentId == item1.StudentId)
{
StudentsList.Add(item);
}
}
}
var model = new UploadResultViewModel
{
Students = StudentsList,
StudentResult = new StudentResult(),
Course = subject,
Lookups = db.Lookups.Where(c => c.Category == "STUDENT_GRADE").ToList(),
StudentResults = db.StudentResults.ToList()
};
return(View(model));
}
public IActionResult UploadResult(string transID)
{
ViewBag.DoctorName = HttpContext.Session.GetString(Globals.currentUserName);
if (HttpContext.Session.GetString(Globals.currentDSPriK) == null || HttpContext.Session.GetString(Globals.currentDAPriK) == null)
{
return(RedirectToAction("Login"));
}
else if (HttpContext.Session.GetString(Globals.currentPSPubK) == null || HttpContext.Session.GetString(Globals.currentPAPubK) == null)
{
return(RedirectToAction("PatientLookUp"));
}
else
{
ViewBag.DoctorName = HttpContext.Session.GetString(Globals.currentUserName);
Assets <PatientCredAssetData> userAsset = _bigChainDbService.GetPatientAssetFromID(HttpContext.Session.GetString(Globals.currentPPHN));
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);
PatientCredMetadata userMetadata = _bigChainDbService.GetMetadataFromAssetPublicKey <PatientCredMetadata>(userAsset.id, patientSignPublicKey);
var patientInfo = userAsset.data.Data;
patientInfo.FingerprintData = null;
var testRequisition = _bigChainDbService.GetMetaDataAndAssetFromTransactionId <string, double>(transID);
if (testRequisition.metadata.AccessList.Keys.Contains(doctorSignPublicKey))
{
var hashedKey = testRequisition.metadata.AccessList[doctorSignPublicKey];
var dataDecryptionKey = EncryptionService.getDecryptedEncryptionKey(hashedKey, doctorAgreePrivateKey);
var data = EncryptionService.getDecryptedAssetData(testRequisition.data.Data, dataDecryptionKey);
var asset = JsonConvert.DeserializeObject <TestRequisitionAsset>(data);
asset.AttachedFile.Data = null;
var viewModel = new UploadResultViewModel()
{
TestData = new TestRequisitionFullData
{
assetData = asset,
Metadata = testRequisition.metadata.data,
assetID = testRequisition.id,
transID = testRequisition.transID
},
PatientAsset = patientInfo,
PatientMetadata = userMetadata
};
TempData["viewModel"] = JsonConvert.SerializeObject(viewModel);
return(View(viewModel));
}
else
{
return(new EmptyResult());
}
}
}
public IActionResult Upload(IFormFile formFile, UploadResultViewModel model)
{
if (model == null)
{
model = new UploadResultViewModel();
}
//Check submitted file
if (formFile != null && formFile.Length > 0)
{
using (var fileStream = formFile.OpenReadStream())
{
using (Image <Rgba32> image = Image.Load(fileStream))
{
//Resize and create Base64 string
image.Mutate(x => x
.Resize(80, 80));
model.Image = image.ToBase64String(ImageFormats.Png);
}
}
}
else if (!string.IsNullOrEmpty(model.Image) && !string.IsNullOrEmpty(model.Address))
{
try
{
//Submit base64 image to smartcontract
var script = NeoAPI.GenerateScript(_scriptHash, "add", new object[] { model.Address, model.Image });
var invoke = NeoAPI.TestInvokeScript(NeoAPI.Net.Test, script);
//Check result
if (invoke.result is byte[])
{
var textresult = System.Text.Encoding.ASCII.GetString((byte[])invoke.result);
}
}
catch { }
//Get hash
//string sha1hash = Sha1Hash(model.Address);
//return RedirectToAction("Preview", new { id = sha1hash });
return(View("Preview", new PreviewViewModel()
{
Image = model.Image
}));
}
return(View(model));
}
public ActionResult UploadResult(int id, UploadResultViewModel model)
{
for (int i = 0; i < model.Students.Count; i++)
{
Student Std = model.Students[i];
Lookup lup = model.Lookups[i];
if (!db.StudentResults.Any(c => c.StudentId == Std.StudentId && c.CourseId == id))
{
var studentResult = new StudentResult
{
StudentId = Std.StudentId,
Grade = lup.LookupId,
CourseId = id
};
db.StudentResults.Add(studentResult);
}
}
db.SaveChanges();
return(RedirectToAction("CoursesList1"));
}
public async Task <IActionResult> GetUploadSearchResults(string url, [FromServices] ICompositeViewEngine viewEngine)
{
Upload.Models.Upload foundUpload = _dbContext.Uploads.Where(u => u.Url == url).FirstOrDefault();
if (foundUpload != null)
{
UploadResultViewModel model = new UploadResultViewModel();
model.Url = foundUpload.Url;
model.ContentType = foundUpload.ContentType;
model.ContentLength = foundUpload.ContentLength;
model.DateUploaded = foundUpload.DateUploaded;
model.Downloads = foundUpload.Downloads;
model.DeleteKey = foundUpload.DeleteKey;
model.Username = foundUpload.User?.Username;
string renderedView = await RenderPartialViewToString(viewEngine, "~/Areas/Admin/Views/Admin/UploadResult.cshtml", model);
return(Json(new { result = new { html = renderedView } }));
}
return(Json(new { error = new { message = "Upload does not exist" } }));
}
public ActionResult UploadResultsFile(int runId)
{
var model = new UploadResultViewModel();
using (var context = new Entities())
{
var run = context.TestRuns.Find(runId);
if (run.Status != "In progress")
{
throw new UnauthorizedAccessException();
}
model.RunNumber = runId;
model.TestName = context.TestSets.Find(run.TestSetId).Name;
model.AlgorithmName = context.Algorithms.Find(run.AlgorithmId).Name;
model.RepeatNumber = (run.RunsNumber == null ||
run.RunsNumber == "roc calculation") ? "roc calculation" //todo
: run.RunsNumber.ToString();
model.RocCalc = run.RocCurveCalc == true ? "yes" : "no";
}
return(View(model));
}
public UploadResultViewModel Upload(Repository repository,
string siteName,
MediaFolder folder,
string name,
Stream stream)
{
var result = new UploadResultViewModel();
try
{
stream.Position = 0;
var content = _mediaContentManager.Add(repository, folder, name, stream, true);
result.state = "SUCCESS";
result.url = content.Url;
result.title = content.FileName;
result.original = content.FileName;
}
catch (Exception ex)
{
result.state = ex.Message;
result.error = ex.Message;
}
return(result);
}
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 ActionResult UploadResultsFile(UploadResultViewModel model)
{
var regex = new Regex("^([0-9]|[0-9][0-9]|[0-9][0-9][0-9]|[0-9][0-9][0-9][0-9]|[0-9][0-9][0-9][0-9][0-9])$");
if (model.RocCalc == "yes" && !regex.IsMatch(model.RocClassNumber))
{
ModelState.AddModelError("CustomErrorRoc", "Incorrect class number.");
return(View(model));
}
if (model.file == null)
{
ModelState.AddModelError("CustomError", "Please, attach test results file.");
return(View(model));
}
else
{
using (var context = new Entities())
{
var run = context.TestRuns.Find(model.RunNumber);
run.RocClassNumber = model.RocClassNumber;
var results = new TestResults()
{
AlgorithmId = context.Algorithms
.Where(x => x.Name == model.AlgorithmName).ToArray()[0].Id,
TestRunId = model.RunNumber
};
var test = context.TestSets.Where(x => x.Name == model.TestName).ToArray()[0];
try
{
var analyzer = new TestResultsAnalyzer();
if (model.RocCalc == "no")
{
using (MemoryStream ms = new MemoryStream())
{
model.file.InputStream.CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
var statistics = analyzer.CalcErrorPercentage
(test.ExpectedResults, ms, Convert.ToInt32(model.RepeatNumber));
results.CorrectRate = statistics.ToString("0.000");
context.TestResults.Add(results);
context.SaveChanges();
run.Status = "Results saved";
context.SaveChanges();
return(RedirectToAction("RunResults", new { resultsId = results.Id }));
}
}
else if (model.RocCalc == "yes")
{
using (MemoryStream ms = new MemoryStream())
{
model.file.InputStream.CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
var rocCreator = new RocCurveCreator();
var sbSensivity = new StringBuilder();
var sbSpecifity = new StringBuilder();
var statistics = rocCreator.GenerateRocCurveCoordinates(test.ExpectedResults, ms, model.RocClassNumber);
for (var i = 0; i < statistics.rocCoordinatesSensivity.Count(); i++)
{
sbSensivity.Append(statistics.rocCoordinatesSensivity[i].ToString("0.000") + " ");
sbSpecifity.Append(statistics.rocCoordinatesSpecifity[i].ToString("0.000") + " ");
}
var AUCrate = rocCreator.CalculateAUC(sbSpecifity.ToString(), sbSensivity.ToString());
results.RocCoordinatesSensiv = sbSensivity.ToString();
results.RocCoordinatesSpecif = sbSpecifity.ToString();
results.FN = statistics.FalseNegativeNumber.Average().ToString("0.000");
results.FP = statistics.FalsePositiveNumber.Average().ToString("0.000");
results.TN = statistics.TrueNegativeNumber.Average().ToString("0.000");
results.TP = statistics.TruePositiveNumber.Average().ToString("0.000");
results.CorrectRate = statistics.ErrorRate.ToString("0.000");
results.OtherInfo = AUCrate.ToString("0.000");
context.TestResults.Add(results);
context.SaveChanges();
run.Status = "Results saved";
context.SaveChanges();
return(RedirectToAction("RunResultsRoc", new { resultsId = results.Id }));
}
}
}
catch (Exception)
{
ModelState.AddModelError("FileFormatException", "Error occured in results processing. Please check file format.");
return(View(model));
}
}
}
ModelState.AddModelError("FileFormatException", "Server error.");
return(View(model));
}
