public void Calculate_Sum()
{
Doctor d = new Doctor();
Patient p1 = new Patient("Ivo", "Ivić", "01234567890", DateTime.Now, "ii01234");
Patient p2 = new Patient("Filip", "Filipović", "01234567891", DateTime.Now, "ff01234");
ExaminationType t1 = new ExaminationType("EKG", 100);
ExaminationType t2 = new ExaminationType("holter", 132);
MedicalExamination e1 = new MedicalExamination(d, p1, DateTime.Now, t1);
MedicalExamination e2 = new MedicalExamination(d, p2, DateTime.Now, t1);
MedicalExamination e3 = new MedicalExamination(d, p1, DateTime.Now, t2);
List <MedicalExamination> examinations = new List <MedicalExamination>();
examinations.Add(e1);
examinations.Add(e2);
examinations.Add(e3);
Statistics stat = new Statistics(examinations);
stat.Calculate();
Assert.AreEqual(332, stat.priceSum);
Assert.AreEqual(2, stat.patientCount);
}
public bool DeleteExaminationType(int?id, ExaminationType examinationType)
{
try
{
var obj = JsonConvert.SerializeObject
(new ExaminationType
{
ExaminationTypeId = examinationType.ExaminationTypeId,
UserId = examinationType.UserId,
TokenId = examinationType.TokenId
});
var ExamTypeObj = obj.ToString();
var JsonObj = db.RemoveExamination(id, ExamTypeObj);
return(true);
}
catch (Exception ex)
{
Console.WriteLine("NotImplementedException", ex);
return(false);
}
}
public IHttpActionResult PutExaminationType(Guid id, ExaminationType examinationType)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != examinationType.ExaminationTypeId)
{
return(BadRequest());
}
db.Entry(examinationType).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ExaminationTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// 初始化测试数据
/// </summary>
/// <param name="question">Question.</param>
/// <param name="answers">Answers.</param>
/// <param name="correctAnswerIndex">Correct answer index.</param>
/// <param name="examType">Exam type.</param>
public Examination(LearnWord questionWord, LearnWord[] choiceWordsArray, ExaminationType examType)
{
this.question = questionWord;
this.wordsArray = choiceWordsArray;
switch (examType)
{
case ExaminationType.EngToChn:
examTypeList = new List <ExaminationType> {
ExaminationType.EngToChn
};
break;
case ExaminationType.ChnToEng:
examTypeList = new List <ExaminationType> {
ExaminationType.ChnToEng
};
break;
case ExaminationType.Both:
examTypeList = new List <ExaminationType> {
ExaminationType.EngToChn, ExaminationType.ChnToEng
};
break;
}
RandomAnswersFromLearningWords(choiceWordsArray);
}
// POST: odata/ExaminationTypes
public IHttpActionResult Post(ExaminationType examinationType)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.ExaminationTypes.Add(examinationType);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (ExaminationTypeExists(examinationType.ExaminationTypeId))
{
return(Conflict());
}
else
{
throw;
}
}
return(Created(examinationType));
}
public Examination Read(string filePath)
{
XSSFWorkbook xssfBook;
using (FileStream file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
xssfBook = new XSSFWorkbook(file);
}
ISheet sheet = xssfBook.GetSheet(xssfBook.GetSheetName(0));
Patient client = ReadClient(sheet);
ExaminationType type = sheet.GetExaminationType();
if (type == ExaminationType.UNKNOWN)
{
throw new UnknownExaminationTypeException(Path.GetFileName(filePath));
}
else if (type == ExaminationType.CANDIDIASIS)
{
return(CreateCandidiasisExamination(sheet, type, client));
}
else
{
return(CreateExamination(sheet, type, client));
}
}
public void AddExaminationToPatient(int patientId, Examination exam, ExaminationType examType, IExaminationType examData, WorkFlow workFlow)
{
var patient = GetPatient(patientId, true);
patient.Examinations.Add(exam);
exam.WorkFlow = workFlow;
_context.SaveChanges();
if (examType == ExaminationType.BloodPressure)
{
BloodPressureData ExanData = examData as BloodPressureData;
_context.BloodPressureData.Add(examData as BloodPressureData);
ExanData.ExaminationId = exam.Id;
_context.SaveChanges();
}
if (examType == ExaminationType.BloodSpO2)
{
SpOData ExanData = examData as SpOData;
_context.SpOData.Add(examData as SpOData);
ExanData.ExaminationId = exam.Id;
_context.SaveChanges();
}
if (examType == ExaminationType.BodyTemperature)
{
BodyTemperatureData ExanData = examData as BodyTemperatureData;
ExanData.ExaminationId = exam.Id;
_context.BodyTemperatureData.Add(examData as BodyTemperatureData);
ExanData.ExaminationId = exam.Id;
_context.SaveChanges();
}
}
public bool InsUpdExaminationType(int?id, ExaminationType examinationType)
{
try
{
var obj = JsonConvert.SerializeObject
(new ExaminationType
{
ExaminationTypeId = examinationType.ExaminationTypeId,
ExamName = examinationType.ExamName,
ExamGroup = examinationType.ExamGroup,
MinMarks = examinationType.MinMarks,
MaxMarks = examinationType.MaxMarks,
FeeLabel = examinationType.FeeLabel,
Amount = examinationType.Amount,
UserId = examinationType.UserId,
TokenId = examinationType.TokenId,
});
var ExamTypeObj = obj.ToString();
var JsonObj = db.UpdateExamination(id, ExamTypeObj);
return(true);
//db.ExaminationTypes.Add(examinationType);
//db.SaveChanges();
//return true;
}
catch (Exception ex)
{
Console.WriteLine("NotImplementedException", ex);
return(false);
}
}
public ExaminationType GetCurrentExamType()
{
int examTypeIndex = Random.Range(0, examTypeList.Count);
currentExamType = examTypeList [examTypeIndex];
return(currentExamType);
}
public IHttpActionResult Delete(ExaminationType examinationType)
{
var isDeleted = examinationTypeService.DeleteExaminationType(examinationType.UniversityId, examinationType);
if (isDeleted == true)
{
return(Ok());
}
return(BadRequest());
}
public IHttpActionResult Save(ExaminationType examinationType)
{
var isUpdate = examinationTypeService.InsUpdExaminationType(examinationType.UniversityId, examinationType);
if (isUpdate == true)
{
return(Ok());
}
return(BadRequest());
}
public IHttpActionResult GetExaminationType(Guid id)
{
ExaminationType examinationType = db.ExaminationTypes.Find(id);
if (examinationType == null)
{
return(NotFound());
}
return(Ok(examinationType));
}
internal static TypeOfExamination ToBackendExaminationType(this ExaminationType type)
{
switch (type)
{
case ExaminationType.Examination:
return(TypeOfExamination.GENERAL);
default:
return(TypeOfExamination.SURGERY);
}
}
public void AddNewMedicalExamination(IAddMedicalExaminationView inForm)
{
_form = inForm;
List <ExaminationType> typesList = _serviceFactory.CreateExaminationTypeService(_unitOfWork).GetAll();
if (inForm.ShowViewModal(typesList))
{
try
{
bool emergency = inForm.Emergency;
ExaminationType examinationType = inForm.ExaminationType;
string PatientId = inForm.PatientId;
string FirstName = inForm.PatientFirstName;
string LastName = inForm.PatientLastName;
string OIB = inForm.PatientOIB;
string address = inForm.Address;
string city = inForm.City;
string zipCode = inForm.ZipCode;
DateTime DateOfBirth;
DateTime.TryParseExact(inForm.PatientDateOfBirth, "dd.MM.yyyy", null, DateTimeStyles.None, out DateOfBirth);
var patientService = _serviceFactory.createPatientService(_unitOfWork);
var patient = patientService.GetByOIB(OIB);
if (patient == null)
{
patient = patientService.Add(FirstName, LastName, OIB, DateOfBirth, PatientId, address, city, zipCode);
}
Employee employee = LoggedIn.GetEmployee();
WaitingRoom waitingRoom = LoggedIn.GetWaitingRoom();
IMedicalExaminationService medicalExaminationService = _serviceFactory.createMedicalExaminationService(_unitOfWork);
MedicalExamination medicalExamination = medicalExaminationService.Add(patient, examinationType, emergency);
//WaitingRoom waitingRoom = LoggedIn.GetEmployee().WaitingRoom;
//var service = _serviceFactory.CreateWaitingRoomService(_unitOfWork);
//WaitingRoom wr = service.GetById(waitingRoom.Id);
//WaitingRoom wr = new WaitingRoom(new List<MedicalExamination>(), "Kardio");
//wr.AddExamination(medicalExamination);
//service.Add(wr);
NotifyObservers();
}
catch (Exception ex)
{
MessageBox.Show(ex.StackTrace);
}
}
}
public Examination(int newExaminationId, DateTime newStartTime, DateTime newEndTime, string newDoctor, string newPatient, int newRoomId, ExaminationType type)
{
ExaminationId = newExaminationId;
StartTime = newStartTime;
EndTime = newEndTime;
doctor = new Doctor(newDoctor);
patient = new Patient(newPatient);
room = new Room(newRoomId);
deleted = false;
ExaminationType = type;
}
public IHttpActionResult DeleteExaminationType(Guid id)
{
ExaminationType examinationType = db.ExaminationTypes.Find(id);
if (examinationType == null)
{
return(NotFound());
}
db.ExaminationTypes.Remove(examinationType);
db.SaveChanges();
return(Ok(examinationType));
}
// DELETE: odata/ExaminationTypes(5)
public IHttpActionResult Delete([FromODataUri] Guid key)
{
ExaminationType examinationType = db.ExaminationTypes.Find(key);
if (examinationType == null)
{
return(NotFound());
}
db.ExaminationTypes.Remove(examinationType);
db.SaveChanges();
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <SuggestionsDto> GetAllAsync(ExaminationType examinationType)
{
var codes = await context.ExaminationCodes
.Where(code => code.Type == examinationType)
.Select(code => new SuggestionsDto.Suggestion()
{
label = code.Abbreviation + ": " + code.Name,
value = code.Id
}).ToArrayAsync();
return(new SuggestionsDto()
{
Suggestions = codes
});
}
private Examination CreateCandidiasisExamination(ISheet sheet, ExaminationType type, Patient client)
{
var examination = new CandidiasisExamination(sheet);
var candidiasisExamination = new Examination
{
Type = type,
Hash = Hash.Generate(examination.Id + client.Id),
Owner = client,
Ph = examination.Ph,
StoolConsistency = Converter.SetConsistency(examination.StoolConsistency),
Results = SetCandidiasisResults(examination)
};
return(candidiasisExamination);
}
public void Add_InvalidDate_Examinations()
{
// arrange
WaitingRoom waitingRoom = new WaitingRoom();
Doctor doctor = new Doctor();
Patient patient = new Patient();
DateTime today = DateTime.Today.AddDays(-1);
ExaminationType type = new ExaminationType();
MedicalExamination medicalExamination = new MedicalExamination(doctor, patient, today, type);
// act
waitingRoom.AddExamination(medicalExamination);
// assert
Assert.AreEqual(0, waitingRoom.Examinations.Count);
}
public MedicalExamination Add(Patient inPatient, ExaminationType inExaminationType, bool isEmergency)
{
var employee = LoggedIn.GetEmployee();
MedicalExamination medicalExamination;
if (employee is Doctor)
{
medicalExamination = new MedicalExamination(LoggedIn.GetWaitingRoom(), (Doctor)employee, inPatient, DateTime.Now, inExaminationType);
}
else
{
medicalExamination = new MedicalExamination(LoggedIn.GetWaitingRoom(), LoggedIn.GetWaitingRoom().Doctor, inPatient, DateTime.Now, inExaminationType);
}
repository.Add(medicalExamination);
return(medicalExamination);
}
private Examination CreateExamination(ISheet sheet, ExaminationType type, Patient client)
{
var reader = new ExtendedExaminationReader(sheet);
var examination = new Examination
{
Type = type,
Hash = Hash.Generate(reader.Id + client.Id),
Owner = client,
Ph = reader.Ph,
StoolConsistency = Converter.SetConsistency(reader.StoolConsistency),
GeneralNumberOfBacteria = reader.GeneralNumberOfBacteria,
Results = reader.Results
};
if (type == ExaminationType.EXTENDED)
{
return(SetExtendedValues(reader, examination));
}
return(examination);
}
// PUT: odata/ExaminationTypes(5)
public IHttpActionResult Put([FromODataUri] Guid key, Delta <ExaminationType> patch)
{
Validate(patch.GetEntity());
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ExaminationType examinationType = db.ExaminationTypes.Find(key);
if (examinationType == null)
{
return(NotFound());
}
patch.Put(examinationType);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ExaminationTypeExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(examinationType));
}
public async Task <IActionResult> GetSuggestionsAsync(ExaminationType examinationType)
{
var suggestions = await examinationCodeRepository.GetAllAsync(examinationType);
return(new JsonResult(suggestions));
}
public async Task <IActionResult> GetSuggestionsAsync([FromQuery] ExaminationType examinationType)
{
return(await examinationCodeService.GetSuggestionsAsync(examinationType));
}
private void ExaminationInit(DataContext db)
{
Random rand = new Random();
byte[] bytes = File.ReadAllBytes("../../Images/forest.jpg");
PngToJpgConverter converter = new PngToJpgConverter();
var some = converter.ConvertImage(bytes);
var stream1 = new MemoryStream(bytes);
JpegBitmapDecoder decoder = new JpegBitmapDecoder(stream1, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
BitmapFrame frame = decoder.Frames[0];
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.QualityLevel = 60;
encoder.Frames.Add(frame);
byte[] newBytes;
using (var stream = new MemoryStream())
{
encoder.Save(stream);
newBytes = stream.GetBuffer();
}
byte[] bytes2 = File.ReadAllBytes("../../Images/mountain.jpg");
var stream2 = new MemoryStream(bytes2);
var some2 = converter.ConvertImage(bytes2);
JpegBitmapDecoder decoder2 = new JpegBitmapDecoder(stream2, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
BitmapFrame frame2 = decoder2.Frames[0];
JpegBitmapEncoder encoder2 = new JpegBitmapEncoder();
encoder2.QualityLevel = 60;
encoder2.Frames.Add(frame2);
byte[] newBytes2;
using (var stream = new MemoryStream())
{
encoder2.Save(stream);
newBytes2 = stream.GetBuffer();
}
var list = db.Patients.ToList();
foreach (var patient in list)
{
if (rand.Next(0, 2) == 0)
{
continue;
}
for (int i = 0; i < 1; i++)
{
ExaminationType type = db.ExaminationTypes.ToList()
[rand.Next(0, db.ExaminationTypes.ToList().Count)];
Examination examination = new Examination
{
Diagnosis = "Some Diagnosis",
PatientId = patient.Id,
ExaminationTypeId = type.Id,
ExaminationDate = DateTime.Now,
Descripton = "Some Descripton"
};
Examination examination2 = new Examination
{
Diagnosis = "Some Diagnosis2",
PatientId = patient.Id,
ExaminationTypeId = type.Id,
ExaminationDate = DateTime.Now,
Descripton = "Some Descripton2"
};
db.Examinations.Add(examination);
db.Examinations.Add(examination2);
db.SaveChanges();
ExaminationData data = new ExaminationData
{
ExaminationId = examination.Id,
Data = newBytes
};
ExaminationData data2 = new ExaminationData
{
ExaminationId = examination.Id,
Data = newBytes2
};
db.ExaminationDatas.Add(data);
db.ExaminationDatas.Add(data2);
db.SaveChanges();
}
}
}
