/// <summary>
/// Get most recent tratment plan
/// </summary>
/// <returns>Most recent Accpeted treatment plan</returns>
public TreatmentPlan GetMostRecent()
{
TreatmentPlan mostResent = TreatmentPlans[0];
if (Data.IsTreatmentID)
{
foreach (var tp in TreatmentPlans)
{
if (tp.TreatmentPLanID == Data.TreatmentId)
{
mostResent = tp;
}
}
}
else
{
foreach (var tp in TreatmentPlans)
{
if (TreatmentPlans.IndexOf(tp) == 0)
{
continue;
}
if (tp.State == TreatmentPlaneState.Accepted && tp.CreationDate < mostResent.CreationDate)
{
mostResent = tp;
}
}
}
return(mostResent);
}
public TreatmentPlan(TreatmentPlan tp)
{
TreatmentNumber = tp.TreatmentNumber;
CreationTime = tp.CreationTime;
Plan = new List <Challenge>();
Plan.AddRange(tp.Plan);
}
public TreatmentPlan GetTreatmentPlan(int id, tech_assessmentContext context)
{
//get a single Treatment Plan by id
TreatmentPlan treatmentPlan = context.TreatmentPlans.Find(id);
return(treatmentPlan);
}
public Patient()
{
MotionRange = new MotionRange();
CurrentTreatment = null;
TreatmentsHistory = new List <TreatmentPlan>();
Hand = "Right";
}
public void testRecordTreatementPlan()
{
Mock <ITreatmentPlanRepository> treatmentPlanRepository = new Mock <ITreatmentPlanRepository>();
Mock <IPresenterFactory> presenterFactory = new Mock <IPresenterFactory>();
Mock <IRecordTreatmentForm> recordTreatmentForm = new Mock <IRecordTreatmentForm>();
Mock <ITreatmentConsentView> treatmentConsentView = new Mock <ITreatmentConsentView>();
recordTreatmentForm.Object.patientID = 1;
recordTreatmentForm.Object.proposedTreatmentValue = "ROOT_CANAL_WORK";
recordTreatmentForm.Object.treatmentNotes = "Root canal treatment is required";
TreatmentPlan treatmentPlan = new TreatmentPlan();
treatmentPlan.proposedTreatment = "EXAMINATION";
treatmentPlan.bookedDate = DateTime.Now.Subtract(TimeSpan.FromDays(70));
TreatmentConsentPresenter treatmentConsentPresenter = new
TreatmentConsentPresenter(treatmentPlanRepository.Object, treatmentPlan);
treatmentPlanRepository.Setup(x => x.getTreatmentPlan(recordTreatmentForm.Object.patientID))
.Returns(treatmentPlan);
presenterFactory.Setup(x => x.getTreatmentConsentPresenter(
It.IsAny <ITreatmentPlanRepository>(), It.IsAny <TreatmentPlan>())).Returns(treatmentConsentPresenter);
RecordTreatmentPresenter recordTreatmentPresenter = new
RecordTreatmentPresenter(presenterFactory.Object, treatmentPlanRepository.Object);
recordTreatmentPresenter.view = recordTreatmentForm.Object;
recordTreatmentPresenter.recordTreatementPlan(treatmentConsentView.Object);
//Assert.AreEqual(ApplicationConstants.BAND2, treatmentConsentView.Object.treatmentCost);
}
/// <summary>
/// Navigate to treatment on click
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AcceptedTPListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ListView lv = (ListView)sender;
int id = lv.SelectedIndex;
string name = lv.Name;
TreatmentPlan tp = null;
switch (name)
{
case "AcceptedTPListView":
tp = ViewModel.AcceptedTreatmentPlans[id];
break;
case "CreatedTPListView":
tp = ViewModel.CreatedTreatmentPlans[id];
break;
case "FinishTPListView":
tp = ViewModel.FinishedTreatmentPlans[id];
break;
}
Frame.Navigate(typeof(TreatmentPlanView), tp,
new DrillInNavigationTransitionInfo());
}
public bool UpdateTreatmentPlan(TreatmentPlan treatmentPlanData)
{
try
{
using (var dbModel = InitiateDbContext())
{
var entity = dbModel.TreatmentPlans.Find(treatmentPlanData.Id);
if (entity == null)
{
return(false);
}
dbModel.Entry <TreatmentPlan>(entity).CurrentValues.SetValues(treatmentPlanData);
dbModel.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
throw;
}
}
public bool InsertTreatmentPlan(TreatmentPlan treamentPlan)
{
using (var context = new tech_assessmentContext())
{
return(treatmentService.InsertTreatmentPlan(treamentPlan.PatientId, treamentPlan.Diagnosis, treamentPlan.Service,
treamentPlan.Drug, treamentPlan.Jcode, context));
}
}
public Patient()
{
MotionRange = new MotionRange();
CurrentTreatment = null;
TreatmentsHistory = new List <TreatmentPlan>();
MotionRangeHistory = new List <MotionRange>();
Hand = "Right";
LastSkyBoxIndex = 0;
}
public void testGetAppointments()
{
Mock <IRepositoryFactory> repositoryFactory = new Mock <IRepositoryFactory>();
Mock <IAppointmentListView> appointmentListView = new Mock <IAppointmentListView>();
Mock <IPatientRepository> patientRepository = new Mock <IPatientRepository>();
Mock <ITreatmentPlanRepository> treatmentPlanRepository = new Mock <ITreatmentPlanRepository>();
Mock <IAppointmentRepository> appointmentRepository = new Mock <IAppointmentRepository>();
List <Appointment> bookedAppointments = new List <Appointment>();
Appointment appointment = new Appointment();
appointment.ID = 1;
appointment.patientID = 1;
appointment.bookingDate = DateTime.Now.AddDays(7);
appointment.bookingSlot = "09-10";
appointment.treatmentType = "CHECKUP";
bookedAppointments.Add(appointment);
List <TreatmentPlan> treatmentPlans = new List <TreatmentPlan>();
TreatmentPlan treatmentPlan = new TreatmentPlan();
treatmentPlan.ID = 1;
treatmentPlan.patientID = 2;
treatmentPlan.proposedTreatment = "ROOT_CANAL_WORK";
TreatmentConsentAndPayment treatmentConsentAndPayment = new TreatmentConsentAndPayment();
treatmentConsentAndPayment.consentText = "";
treatmentConsentAndPayment.ID = 1;
treatmentConsentAndPayment.isAccepted = true;
treatmentConsentAndPayment.treatmentCost = ApplicationConstants.BAND2;
treatmentPlan.treatmentConsentAndPayment = treatmentConsentAndPayment;
treatmentPlans.Add(treatmentPlan);
Patient patient = new Patient();
patient.name = "venkat";
patient.email = "*****@*****.**";
patient.phoneNumber = "1234567890";
// mock patient repo
repositoryFactory.Setup(x => x.getRepository("PATIENT")).Returns(patientRepository.Object);
patientRepository.Setup(x => x.getPatient(It.IsAny <int>())).Returns(patient);
//mock appointment repo
repositoryFactory.Setup(x => x.getRepository("APPOINTMENT")).Returns(appointmentRepository.Object);
appointmentRepository.Setup(x => x.getBookings()).Returns(bookedAppointments);
//mock treatmentplan repo
repositoryFactory.Setup(x => x.getRepository("TREATMENTPLAN")).Returns(treatmentPlanRepository.Object);
treatmentPlanRepository.Setup(x => x.getTreatmentPlans()).Returns(treatmentPlans);
AppointmentsListPresenter appointmentsListPresenter = new AppointmentsListPresenter(repositoryFactory.Object);
List <AppointmentList> appointmentList = appointmentsListPresenter.getAppointments();
// I passed two values as input data so I am expecting two values to be updated here
Assert.AreEqual(2, appointmentList.Count);
}
/*
* insert treatment plan
*
*/
public int addTreatmentPlan(TreatmentPlan treatmentPlan)
{
using (var db = new DentalPracticeContext())
{
db.treatmentPlans.Add(treatmentPlan);
int result = db.SaveChanges();
return(result);
}
}
}/// <summary>
/// au auxilliary function which adds a default intervention type
/// </summary>
private void AddNewIntervention()
{
TreatmentPlan plan = db.TreatmentPlans.Where(x => x.Patient_TreatmentPlan.User_id == patient.User_id).FirstOrDefault();
TreatmentType typeDefault = db.TreatmentTypes.Where(x => x.Description == "unset").FirstOrDefault();
db.Interventions.Add(new Intervention {
Treatment = plan, Treatment_type = typeDefault, startsAt = DateTime.Now, endsAt = DateTime.Now
});
db.SaveChanges();
}
private TreatmentPlan createTreatmentPlan()
{
TreatmentPlan treatmentPlan = new TreatmentPlan();
treatmentPlan.patientID = view.patientID;
treatmentPlan.treatmentNotes = view.treatmentNotes;
treatmentPlan.bookedDate = DateTime.Now;
treatmentPlan.proposedTreatment = view.proposedTreatmentValue;
treatmentPlan.treatmentConsentAndPayment = new TreatmentConsentAndPayment();
return(treatmentPlan);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
TreatmentPlan treatmentPlan = await db.TreatmentPlan.FindAsync(id);
int patientId = treatmentPlan.PatientID;
db.TreatmentPlan.Remove(treatmentPlan);
await db.SaveChangesAsync();
return(RedirectToAction("Index", "Treatments", new { id = patientId }));
}
/// <summary>
/// If the patieny is not associated to any plan a new one is created
/// ordem title, startsAt, endsAt
/// </summary>
/// <param name="intervention"></param>
private void CreateNewTreatmentPlan()
{
TreatmentPlan plan = new TreatmentPlan {
Patient_TreatmentPlan = patient
};
TreatmentType typeDefault = db.TreatmentTypes.Where(x => x.Description == "unset").FirstOrDefault();
db.Interventions.Add(new Intervention {
Treatment = plan, Treatment_type = typeDefault, startsAt = DateTime.Now, endsAt = DateTime.Now
});
db.SaveChanges();
}/// <summary>
public async Task <ActionResult> Edit([Bind(Include = "TreatmentPlanID,TreatmentDescription,PatientID")] TreatmentPlan treatmentPlan)
{
if (ModelState.IsValid)
{
int patientID = treatmentPlan.PatientID;
db.Entry(treatmentPlan).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index", "Treatments", new { id = patientID }));
}
return(View(treatmentPlan));
}
public async Task <ActionResult> Create([Bind(Include = "TreatmentPlanID,TreatmentDescription,PatientID")] TreatmentPlan treatmentPlan)
{
if (ModelState.IsValid)
{
db.TreatmentPlan.Add(treatmentPlan);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(treatmentPlan));
}
internal benefitInformation GetBenefitInquiry(int id, int treatmentId, tech_assessmentContext context)
{
//We need a patient as well as a treatment plan to submit benefits verification
benefitInformation information = new benefitInformation();
Patient patient = context.Patients.Find(id);
TreatmentPlan plan = context.TreatmentPlans.Find(treatmentId);
information.PatientName = patient.PatientName;
information.patientInsurance = patient.Insurance;
information.treatmentPlan = plan;
return(information);
}
public void recordTreatementPlan(ITreatmentConsentView treatmentConsentView)
{
TreatmentPlan treatmentPlan = createTreatmentPlan();
treatmentPlan.treatmentConsentAndPayment.treatmentCost =
calculateCost(treatmentPlan.proposedTreatment, treatmentPlan.patientID);
TreatmentConsentPresenter treatmentConsentPresenter = presenterFactory.
getTreatmentConsentPresenter(treatmentPlanRepository, treatmentPlan);
treatmentConsentView.treatmentConsentPresenter = treatmentConsentPresenter;
treatmentConsentPresenter.view = treatmentConsentView;
treatmentConsentPresenter.view.treatmentCost = treatmentPlan.treatmentConsentAndPayment.treatmentCost;
}
// GET: TreatmentPlans/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TreatmentPlan treatmentPlan = await db.TreatmentPlan.FindAsync(id);
if (treatmentPlan == null)
{
return(HttpNotFound());
}
return(View(treatmentPlan));
}
public async Task <ActionResult> AddNewTreatmentPlan(TreatmentPlanDTO obj)
{
TreatmentPlan treatmentPlan = new TreatmentPlan();
treatmentPlan.PatientID = obj.PatientID;
treatmentPlan.TreatmentDescription = obj.TxtValue;
int patientID = treatmentPlan.PatientID;
db.TreatmentPlan.Add(treatmentPlan);
// await db.SaveChangesAsync();
await db.SaveChangesAsync();
return(Json(Url.Action("Index", "Treatments", new { id = patientID })));
}
public Info_TreatmentPlan(TreatmentPlan pl)
{
InitializeComponent();
// передача плана лечения из грида главной формы
plan = pl;
// Ограничение функционала в зависимости от роли
button24.Visible = addBan;
button2.Visible = editBan;
button3.Visible = editBan;
button1.Visible = editBan;
dataGridView4.Columns[8].Visible = delBan;
// Бан полей врача
textBox7.Enabled = false;
textBox1.Enabled = false;
textBox2.Enabled = false;
textBox3.Enabled = false;
// Бан полей пациента
textBox8.Enabled = false;
textBox6.Enabled = false;
textBox5.Enabled = false;
textBox4.Enabled = false;
if (status == 2)
{
button1.Hide();
}
// Находим ID врача и пациента для заполнения полей
int d = plan.AssignerDoctorID;
int p = plan.PatientID;
// Заполняем поля
textBox7.Text = Convert.ToString(OperationsOfPersons.FindByID(d).ID);
textBox1.Text = Convert.ToString(OperationsOfPersons.FindByID(d).Surname);
textBox2.Text = Convert.ToString(OperationsOfPersons.FindByID(d).Name);
textBox3.Text = Convert.ToString(OperationsOfPersons.FindByID(d).Patronymic);
textBox8.Text = Convert.ToString(OperationsOfPersons.FindByID(p).ID);
textBox6.Text = Convert.ToString(OperationsOfPersons.FindByID(p).Surname);
textBox5.Text = Convert.ToString(OperationsOfPersons.FindByID(p).Name);
textBox4.Text = Convert.ToString(OperationsOfPersons.FindByID(p).Patronymic);
PrescriptionGrid();
}
public int CreateTreatmentPlan(TreatmentPlan treatmentPlan)
{
try
{
using (var dbModel = InitiateDbContext())
{
dbModel.TreatmentPlans.Add(treatmentPlan);
dbModel.SaveChanges();
return(treatmentPlan.Id);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
throw;
}
}
/******************************************************************************************************
* Treatments
*****************************************************************************************************/
private void AddTreatment(object sender, RoutedEventArgs e)
{
var ms = (ModalState)EvaluationModal.DataContext;
var problem = NewTreatmentRefProblem.SelectionBoxItem as MajorProblem;
var treatment = new TreatmentPlan {
Description = NewTreatmentDescription.Text, Objective = NewTreatmentObjective.Text, RefProblem = problem
};
if (ms.Treatments.Contains(treatment))
{
return;
}
ms.Treatments.Add(treatment);
NewTreatmentDescription.Text = string.Empty;
NewTreatmentObjective.Text = string.Empty;
NewTreatmentRefProblem.SelectedIndex = -1;
}
public bool UpdateTreatmentPlan(int id, int patientId, string diagnosis, string service, string drug, string jcode, tech_assessmentContext context)
{
//make sure it exsists before attempting to edit
TreatmentPlan treatmentPlan = context.TreatmentPlans.Find(id);
if (treatmentPlan != null)
{
treatmentPlan.PatientId = patientId;
treatmentPlan.Diagnosis = diagnosis;
treatmentPlan.Service = service;
treatmentPlan.Drug = drug;
treatmentPlan.Jcode = jcode;
context.TreatmentPlans.Update(treatmentPlan);
var changes = context.SaveChanges();
//if the changes are equal to 1 the change was sucessful
return(changes == 1);
}
return(false);
}
public bool DeleteTreatmentPlan(int id, tech_assessmentContext context)
{
//make sure it exsists before attempting to delete
TreatmentPlan treatmentPlan = new TreatmentPlan();
treatmentPlan = context.TreatmentPlans.Find(id);
DeleteTreatmentPlanAssociations(context, treatmentPlan);
try
{
//attempt to commit the changes
var changes = context.SaveChanges();
//if the changes are equal to 1 the change was sucessful
return(changes == 1);
}
catch
{
//if commit fails let the requester know
return(false);
}
}
/// <summary>
/// save the list of interventions
/// </summary>
/// <param name="interventions">list of interventions objects</param>
public void SaveInterventions(List <string> interventions)
{
TreatmentPlan treatmentPlan = new TreatmentPlan {
Patient_TreatmentPlan = patient
};
int intervention_id = 0;
int id = 0;
Int32.TryParse(interventions[0], out id);
Int32.TryParse(interventions[3], out intervention_id);
DateTime start = Convert.ToDateTime(interventions[1]);
DateTime end = Convert.ToDateTime(interventions[2]);
TreatmentType type = db.TreatmentTypes.Find(id);
//Intervention newIntervention = new Intervention {startsAt = start ,endsAt = end,Treatment_type = type,Treatment = treatmentPlan };
//db.Interventions.Add(newIntervention);
Intervention updateIntervention = db.Interventions.Find(intervention_id);
updateIntervention.endsAt = end;
updateIntervention.startsAt = start;
updateIntervention.Treatment_type = type;
db.SaveChanges();
}
public void testUpdateTreatmentPlan()
{
TreatmentPlan treatmentPlan = new TreatmentPlan();
treatmentPlan.treatmentConsentAndPayment = new TreatmentConsentAndPayment();
Mock <ITreatmentPlanRepository> treatmentPlanRepository = new Mock <ITreatmentPlanRepository>();
Mock <ITreatmentConsentView> view = new Mock <ITreatmentConsentView>();
view.Object.consentText = "Accept all the conditions";
view.Object.isAccepted = true;
treatmentPlanRepository.Setup(x => x.addTreatmentPlan(It.IsAny <TreatmentPlan>())).Returns(1);
TreatmentConsentPresenter treatmentConsentPresenter =
new TreatmentConsentPresenter(treatmentPlanRepository.Object, treatmentPlan);
treatmentConsentPresenter.view = view.Object;
int updatedRecords = treatmentConsentPresenter.updateTreatmentPlan();
Assert.AreEqual(1, updatedRecords);
}
public ActionResult TreatmentPlan(FormCollection coll)
{
var id = db.TreatmentPlanIDs.FirstOrDefault();
string tpdid = "TP" + (Convert.ToInt32(id.PlanDetailsID) + 1).ToString("0000");
int rowcount = Convert.ToInt32(coll["rowcount"].ToString());
int savedcount = 0;
for (int i = 1; i <= rowcount; i++)
{
TreatmentPlanDetail tpd = new TreatmentPlanDetail();
tpd.TPNumber = tpdid;
tpd.TreatmentName = coll["trname" + i].ToString();
tpd.HealerName = coll["healername" + i].ToString();
tpd.RoomNo = coll["roomid" + i].ToString();
db.TreatmentPlanDetails.Add(tpd);
savedcount += db.SaveChanges();
}
if (savedcount > 0)
{
id.PlanDetailsID = Convert.ToInt32(id.PlanDetailsID) + 1;
db.TreatmentPlanIDs.Attach(id);
db.Entry(id).Property(i => i.PlanDetailsID).IsModified = true;
db.SaveChanges();
TreatmentPlan tp = new TreatmentPlan();
tp.PRNO = coll["guestid"].ToString();
tp.PlanDetailID = tpdid;
tp.TreatmentSession = coll["session"].ToString();
tp.ScheduleDate = DateTime.Today.AddDays(1);
tp.ScheduleTime = TimeSpan.Parse(coll["scheduletime"].ToString());
tp.StartTime = TimeSpan.Parse(coll["starttime"].ToString());
tp.EndTime = TimeSpan.Parse(coll["endtime"].ToString());
tp.CreatedBy = "admin";
tp.CreatedOn = DateTime.Now;
db.TreatmentPlans.Add(tp);
db.SaveChanges();
}
return(View());
}
public bool InsertTreatmentPlan(int patientId, string diagnosis, string service, string drug, string jcode, tech_assessmentContext context)
{
TreatmentPlan treatmentPlan = new TreatmentPlan();
treatmentPlan.PatientId = patientId;
treatmentPlan.Diagnosis = diagnosis;
treatmentPlan.Service = service;
treatmentPlan.Drug = drug;
treatmentPlan.Jcode = jcode;
//attempt to insert new response if it fails returns false
try
{
context.TreatmentPlans.Add(treatmentPlan);
var changes = context.SaveChanges();
//if the changes are equal to 1 the change was sucessful
return(changes == 1);
}
catch
{
return(false);
}
}
