public ExaminationDetail(Patient patient, Examination examination)
{
InitializeComponent();
vm = new ExaminationViewModel(patient, examination);
BindingContext = vm;
_patient = patient;
}
public ActionResult DetailExam(int examId)
{
ExaminationViewModel exam = examinationService.GetDetailExamById(examId);
TempData["active"] = "Examination";
return(View(exam));
}
private static Examination SimplifyCreate(ExaminationViewModel examinationVM)
{
return(new Examination()
{
ExCode = examinationVM.ExCode,
Name = examinationVM.Name,
Disease = examinationVM.Disease
});
}
//GET
// [Authorize(Roles ="Medical")]
public ActionResult Create()
{
_context.Configuration.ProxyCreationEnabled = false;
ExaminationViewModel y = new ExaminationViewModel
{
Users = _context.Users.ToList()
};
return(View(y));
}
public static async Task UpdateExaminationAsync(int id, ExaminationViewModel examinationVM)
{
Examination examinationToUpdate = await _context.Examinations.FindAsync(id);
examinationToUpdate.Disease = examinationVM.Disease;
examinationToUpdate.ExCode = examinationVM.ExCode;
examinationToUpdate.Name = examinationVM.Name;
_context.Examinations.Update(examinationToUpdate);
await _context.SaveChangesAsync();
}
public ExaminationViewModel ToViewListModel(Examination exam)
{
var result = new ExaminationViewModel()
{
ExaminationID = exam.ID,
DoctorFirstName = exam.Doctor.FirstName,
DoctorLastName = exam.Doctor.LastName,
PatientFirstName = exam.Patient.FirstName,
PatientLastName = exam.Patient.LastName,
ExamDate = exam.DateOfVisit,
Diagnose = exam.DiagnoseCode
};
return(result);
}
// GET: Examinations/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
ExaminationViewModel examination = await ExaminationsHelper.GetByIdAsync((int)id);
if (examination == null)
{
return(NotFound());
}
return(View(examination));
}
public ActionResult Index()
{
_context.Configuration.ProxyCreationEnabled = false;
ExaminationViewModel data = new ExaminationViewModel()
{
Exam = _context.Exams.Single(),
Users = _context.Users.ToList()
};
var currentUserId = User.Identity.GetUserId();
List <Examination> exams = _context.Exams.Where(u => u.User.Id == currentUserId).ToList();
ViewBag.Message = "Nie masz żadnych badań, Gratulacje!";
return(View(exams));
}
public ExaminationView(ExaminationViewModel examinationViewModel)
{
InitializeComponent();
ViewModel = examinationViewModel;
_bsExams = new BindingSource();
_bsExams.DataSource = ViewModel.Examinations;
_textBoxDate.DataBindings.Add("Text",
_bsExams, nameof(Examination.ExaminationDate), true);
_textBoxGroup.DataBindings.Add("Text", _bsExams, nameof(Examination.HelthGroupTitle));
_textBoxDiagnosis.DataBindings.Add("Text", _bsExams, nameof(Examination.DiagnosisName));
_textBoxDoctor.DataBindings.Add("Text", _bsExams, nameof(Examination.DoctorFio));
_bsExams.CurrentItemChanged += _bsExams_CurrentItemChanged;
ViewModel.NextClicked += (s, e) => _bsExams.MoveNext();
ViewModel.PreviousClicked += (s, e) => _bsExams.MovePrevious();
this.Load += ExaminationView_Load;
}
public async Task <IActionResult> Create(ExaminationViewModel examinationVM)
{
try
{
if (ModelState.IsValid)
{
await ExaminationsHelper.AddExaminationAsync(examinationVM);
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException)
{
//Log the error
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator.");
}
return(View(examinationVM));
}
// GET: Examinations/Delete/5
public async Task <IActionResult> Delete(int?id, bool?saveChangesError = false)
{
if (id == null)
{
return(NotFound());
}
ExaminationViewModel examination = await ExaminationsHelper.GetByIdAsync((int)id);
if (examination == null)
{
return(NotFound());
}
if (saveChangesError.GetValueOrDefault())
{
ViewData["ErrorMessage"] = "Delete failed. Try again, and if the problem persists " +
"see your system administrator.";
}
return(View(examination));
}
public async Task <IActionResult> Examinations(string Id, string returnUrl, string search)
{
var vm = new ExaminationViewModel
{
PacientId = Id,
ReturnUrl = returnUrl,
Search = search
};
var card = await _cardService.GetCardByIdAsync(Id);
if (!string.IsNullOrEmpty(search))
{
vm.Examinations = await _cardService.SearchExaminations(card.Id, search)
.OrderBy(x => x.ExaminationDate).ToListAsync();
}
else
{
vm.Examinations = await _cardService.GetExaminations(card.Id)
.OrderBy(x => x.ExaminationDate).ToListAsync();
}
return(View(vm));
}
public FileResult ExportExamination(int examinationId, string fileExtension)
{
logService.LogManually("Export", "Examination", targetId: examinationId, controller: "ExaminationAPI", method: "ExportExamination", fullname: User.Get(u => u.FullName), usercode: User.Get(u => u.Code));
ExaminationViewModel exam = examinationService.GetExanById(examinationId);
string fileName = exam.Course.Code + "_" + exam.ExamGroup + "_" + exam.ExamCode + "_" + DateTime.Now.ToString("yyyyMMdd");
List <QuestionInExamViewModel> questions = new List <QuestionInExamViewModel>();
foreach (var part in exam.PartOfExam)
{
questions = questions.Concat(part.Question).ToList();
}
if (fileExtension.ToLower().Equals("xml"))
{
byte[] byteArray = ExportToXMLFile(questions);
return(File(byteArray, System.Net.Mime.MediaTypeNames.Application.Octet, fileName + ".xml"));
}
else
{
byte[] byteArray = ExportToGIFTFile(questions);
return(File(byteArray, System.Net.Mime.MediaTypeNames.Application.Octet, fileName + ".txt"));
}
}
public async Task <IActionResult> TakeExams(ExaminationViewModel Vmodel)
{
if (ModelState.IsValid)
{
var examcount = _context.Examinations.Count();
var questionCount = _context.Questions.Count();
var model = new Examination
{
Option = Vmodel.Option,
Answer = Vmodel.Answer,
QuestionId = Vmodel.QuestionId,
CandidateId = (int)HttpContext.Session.GetInt32("sessionId"),
ExamCode = HttpContext.Session.GetString("sessionExamCode"),
};
await _context.Examinations.AddAsync(model);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(TakeExam)));
}
;
return(RedirectToAction("ErrorPage", new { message = "Invalid Query" }));
}
public UserControl GetUcViewOutput(string key)
{
switch (key)
{
case "Ob":
var vmO = new ObservationViewModel();
var ucO = new ObservationView(vmO);
return(ucO);
case "Ex":
var vmE = new ExaminationViewModel();
var ucE = new ExaminationView(vmE);
return(ucE);
case "Ho":
var vmH = new HospitalizationViewModel();
var ucH = new HospitalizationView(vmH);
return(ucH);
default:
throw new ArgumentException(nameof(key));
}
}
public async Task <IActionResult> Edit(int?id, ExaminationViewModel examinationVM)
{
if (id == null || id != examinationVM.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await ExaminationsHelper.UpdateExaminationAsync((int)id, examinationVM);
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateConcurrencyException)
{
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
}
return(View(examinationVM));
}
// TODO: Put in ExaminationHelper
public Examination(ExaminationViewModel examinationViewModel)
{
ExCode = examinationViewModel.ExCode;
Name = examinationViewModel.Name;
Disease = examinationViewModel.Disease;
}
public ActionResult EditExams(ExaminationViewModel model, string Group, string Test, int id)
{
return(View());
}
public ActionResult CreateExam(ExaminationViewModel model, string Group, string Test)
{
return(View());
}
public IActionResult Examinations(ExaminationViewModel viewModel)
{
return(RedirectToAction(nameof(Examinations), new { Id = viewModel.PacientId,
returnUrl = viewModel.ReturnUrl, search = viewModel.Search }));
}
public static async Task AddExaminationAsync(ExaminationViewModel examinationVM)
{
_context.Examinations.Add(SimplifyCreate(examinationVM));
await _context.SaveChangesAsync();
}
