Пример #1
0
        public ActionResult Index(string dfn, string filter, string page)
        {
            // *** Show list of dashboard notes by patient

            NoteListModel model = new NoteListModel();

            model.Patient = this.CurrentPatient;

            int pageVal = this.GetPage(page);

            if (!model.Patient.NotFound)
            {
                // *** Set up the pregnancy list filter ***

                // *** Get the pregnancies ***
                List <PregnancyDetails> pregList = PregnancyUtilities.GetPregnancies(this.DashboardRepository, dfn);

                // *** Get the selection ***
                model.PregnancyFilters = PregnancyUtilities.GetPregnanciesSelection(pregList, true);

                // *** Get valid filter ***
                model.CurrentPregnancyFilter = PregnancyUtilities.GetValidatedPregnancyFilter(pregList, filter);

                // *** Set up pregIen for repo ***
                string pregIen = "";
                int    tempIen = -1;
                if (int.TryParse(model.CurrentPregnancyFilter, out tempIen))
                {
                    pregIen = model.CurrentPregnancyFilter;
                }

                // *** Build a list of titles ***
                List <TiuNoteTitle> titlesToInclude = new List <TiuNoteTitle>();
                foreach (object val in Enum.GetValues(typeof(TiuNoteTitle)))
                {
                    titlesToInclude.Add((TiuNoteTitle)val);
                }

                NoteListResult notesResult = this.DashboardRepository.Notes.GetNotesByTitle(titlesToInclude, dfn, pageVal, ItemsPerPage, pregIen);

                if (!notesResult.Success)
                {
                    this.Error(notesResult.Message);
                }
                else
                {
                    model.ProgressNotes = notesResult.Notes;

                    model.ProgressNotePaging.SetPagingData(ItemsPerPage, pageVal, notesResult.TotalResults);

                    model.ProgressNotePaging.BaseUrl = Url.Action("Index", new { dfn = dfn, filter = model.CurrentPregnancyFilter, page = "" });

                    TempData[ReturnUrl] = Url.Action("Index", new { dfn = dfn, filter = model.CurrentPregnancyFilter, page = pageVal });
                }

                model.DetailAction = "Details";
            }

            return(View(model));
        }
        public ActionResult PatientIndex(string dfn, string page)
        {
            // TODO: Make education items pregnancy specific?
            // TODO: Allow passed in pregnancy

            PatientEducationIndex model = new PatientEducationIndex();

            model.Patient = this.CurrentPatient;

            //PregnancyUtilities util = new PregnancyUtilities(this.DashboardRepository);

            PregnancyDetails preg = PregnancyUtilities.GetWorkingPregnancy(this.DashboardRepository, dfn, "");

            if (preg != null)
            {
                if ((preg.EDD != DateTime.MinValue) || (preg.EndDate != DateTime.MinValue))
                {
                    GetMergedList(model, preg);
                }
                else
                {
                    GetPatientEducationItemList(model);
                }
            }
            else
            {
                GetPatientEducationItemList(model);
            }

            return(View(model));
        }
Пример #3
0
        public ActionResult CreateNote(string dfn)
        {
            // *** Create a new dashboard note ***

            TiuNoteModel model = new TiuNoteModel();

            model.Patient = this.CurrentPatient;

            // *** Get a list of pregnancies ***
            List <PregnancyDetails> pregList = PregnancyUtilities.GetPregnancies(this.DashboardRepository, dfn);

            // *** Get pregnancy selection dictionary ***
            model.Pregnancies = PregnancyUtilities.GetPregnanciesSelection(pregList, false);

            // *** Default to current pregnancy ***
            foreach (PregnancyDetails preg in pregList)
            {
                if (preg.RecordType == PregnancyRecordType.Current)
                {
                    model.Note.PregnancyIen = preg.Ien;
                }
            }

            // *** Set return url ***
            if (TempData.ContainsKey(ReturnUrl))
            {
                model.ReturnUrl     = TempData[ReturnUrl].ToString();
                TempData[ReturnUrl] = TempData[ReturnUrl];
            }

            return(View(model));
        }
        public ActionResult PregnancyIndex(string dfn, string pregIen, string page)
        {
            PregnancyChecklistIndex model = new PregnancyChecklistIndex();

            model.Patient = this.CurrentPatient;

            // TODO: In future add ability to view checklist for a specific pregnancy passed in as parameter
            //       Add a pregnancy selection and display
            //PregnancyDetails preg = PregnancyUtilities.GetWorkingPregnancy(this.DashboardRepository, dfn, pregIen);

            PregnancyDetails preg = PregnancyUtilities.GetWorkingPregnancy(this.DashboardRepository, dfn, "");

            if (preg == null)
            {
                model.NoPregnancies = true;
            }
            else
            {
                if ((preg.EDD == DateTime.MinValue) && (preg.EndDate == DateTime.MinValue))
                {
                    model.NoPregnancyDate = true;
                }

                model.Pregnancy = preg;

                //PregnancyChecklistItemsResult result = this.DashboardRepository.Checklist.GetPregnancyItems(dfn, preg.Ien, "");

                //if (!result.Success)
                //    this.Error(result.Message);
                //else
                //{
                //    model.Items = new PregnancyChecklistItemList();
                //    model.Items.AddRange(result.Items);

                //    model.Items.AddPregnancyDates(preg.EDD, preg.EndDate);

                //    model.Items.Sort(delegate(PregnancyChecklistItem x, PregnancyChecklistItem y)
                //    {
                //        return x.DueDate.CompareTo(y.DueDate);
                //    });
                //}

                PregnancyChecklistItemsResult result = ChecklistUtility.GetSortedPregnancyChecklist(this.DashboardRepository, dfn, preg, DsioChecklistCompletionStatus.Unknown);

                if (!result.Success)
                {
                    this.Error(result.Message);
                }
                else
                {
                    model.Items.AddRange(result.Items);
                }
            }

            // TODO: Paging...

            return(View(model));
        }
Пример #5
0
        public ActionResult CreateNote(TiuNoteModel model)
        {
            // *** Post data ***

            ActionResult returnResult;

            bool needPatDemo = false;

            if (ModelState.IsValid)
            {
                BrokerOperationResult result = this.DashboardRepository.Notes.CreateNote(TiuNoteTitle.MccDashboardNote, model.Patient.Dfn, model.Note.NoteText, model.Note.Subject, new Dictionary <string, string>(), model.Note.PregnancyIen);

                if (!result.Success)
                {
                    this.Error(result.Message);

                    returnResult = View(model);

                    needPatDemo = true;
                }
                else
                {
                    this.Information("Dashboard Note Created");
                    returnResult = RedirectToAction("Index", new { dfn = model.Patient.Dfn, filter = model.Note.PregnancyIen, page = "1" });
                    needPatDemo  = false;
                }
            }
            else
            {
                this.Error("Please enter note details");
                returnResult = View(model);
                needPatDemo  = true;
            }

            // *** Get patient demographics ***
            if (needPatDemo)
            {
                this.CurrentPatientDfn = model.Patient.Dfn;
                model.Patient          = this.CurrentPatient;

                // *** Pregnancies are needed also ***
                // *** Get a list of pregnancies ***
                List <PregnancyDetails> pregList = PregnancyUtilities.GetPregnancies(this.DashboardRepository, this.CurrentPatientDfn);

                // *** Get pregnancy selection dictionary ***
                model.Pregnancies = PregnancyUtilities.GetPregnanciesSelection(pregList, false);
            }

            // *** Set return url ***
            if (TempData.ContainsKey(ReturnUrl))
            {
                model.ReturnUrl     = TempData[ReturnUrl].ToString();
                TempData[ReturnUrl] = TempData[ReturnUrl];
            }

            return(returnResult);
        }
        public static Dictionary <string, string> GetPregnanciesSelection(IDashboardRepository repo, string dfn)
        {
            Dictionary <string, string> returnVal = new Dictionary <string, string>();

            List <PregnancyDetails> pregList = PregnancyUtilities.GetPregnancies(repo, dfn);

            returnVal = PregnancyUtilities.GetPregnanciesSelection(pregList, false);

            return(returnVal);
        }
Пример #7
0
        public ActionResult Edit(string dfn, string ien)
        {
            // *** Create a new dashboard note ***

            TiuNoteModel model = new TiuNoteModel();

            model.Patient = this.CurrentPatient;

            if (!model.Patient.NotFound)
            {
                TiuNoteResult headerResult = this.DashboardRepository.Notes.GetNoteHeader(dfn, ien);

                if (headerResult.Success)
                {
                    model.Note = headerResult.Note;
                    TiuNoteResult noteResult = this.DashboardRepository.Notes.GetNoteBody(ien);

                    if (!noteResult.Success)
                    {
                        this.Error(noteResult.Message);
                    }
                    else
                    {
                        model.Note.NoteText = noteResult.Note.NoteText;
                    }
                }
                else
                {
                    this.Error(headerResult.Message);
                }
            }

            // *** Get pregnancies ***
            model.Pregnancies = PregnancyUtilities.GetPregnanciesSelection(this.DashboardRepository, dfn);

            // *** Set return url ***
            if (TempData.ContainsKey(ReturnUrl))
            {
                model.ReturnUrl     = TempData[ReturnUrl].ToString();
                TempData[ReturnUrl] = TempData[ReturnUrl];
            }

            return(View("CreateNote", model));
        }
Пример #8
0
        public ActionResult AddEdit(string dfn, string pregIen)
        {
            // *** Create the model ***
            PatientOutcomeAddEdit model = new PatientOutcomeAddEdit();

            // *** Make sure patient is set ***
            model.Patient = this.CurrentPatient;

            if (!string.IsNullOrWhiteSpace(pregIen))
            {
                // *** Keep pregnancy ien in model ***
                model.PregnancyIen = pregIen;

                // *** Get the outcome type ***
                PregnancyOutcomeType outcomeType = PregnancyUtilities.GetPregnancyOutcome(this.DashboardRepository, dfn, pregIen);

                // *** Get the outcome details ***
                model.OutcomeDetails = PregnancyUtilities.GetOutcomeDetails(this.DashboardRepository, dfn, pregIen, outcomeType);

                // *** Add outcome type to the model ***
                model.OutcomeDetails.OutcomeType = outcomeType;

                // *** Get the pregnancy details ***
                PregnancyDetails pregDetails = PregnancyUtilities.GetPregnancy(this.DashboardRepository, dfn, pregIen);

                // *** Set the outcome date ***
                if (pregDetails != null)
                {
                    model.OutcomeDetails.OutcomeDate = pregDetails.DisplayEndDate;

                    // *** This is needed for GA in delivery details ***
                    model.Edd = pregDetails.EDD;
                }
            }

            return(View(model));
        }
        public ActionResult Stop(string dfn)
        {
            // *** Show stop tracking page ***

            ActionResult returnResult;

            CreateTrackingEntry model = GetNewModel(TrackingEntryType.Stop, dfn);

            // model.Pregnancy = PregnancyUtilities.GetPregnancy(this.DashboardRepository, dfn, pregIen);

            PregnancyResult results = this.DashboardRepository.Pregnancy.GetCurrentOrMostRecentPregnancy(dfn);

            if (results.Success)
            {
                if (results.Pregnancy != null)
                {
                    string pregIen = results.Pregnancy.Ien;

                    // *** Get the outcome type ***
                    PregnancyOutcomeType outcomeType = PregnancyUtilities.GetPregnancyOutcome(this.DashboardRepository, dfn, pregIen);

                    model.Outcome = PregnancyUtilities.GetOutcomeDetails(this.DashboardRepository, dfn, pregIen, outcomeType);

                    model.Outcome.OutcomeType = outcomeType;

                    model.Outcome.OutcomeDate = results.Pregnancy.DisplayEndDate;
                }
            }



            returnResult = View("~/Views/Track/Stop.cshtml", model);
            //returnResult = View(model);

            return(returnResult);
        }
Пример #10
0
        public ActionResult Details(string dfn, string ien)
        {
            // *** Show details of a dashboard note ***

            TiuNoteModel model = new TiuNoteModel();

            model.Patient = this.CurrentPatient;

            if (!model.Patient.NotFound)
            {
                TiuNoteResult headerResult = this.DashboardRepository.Notes.GetNoteHeader(dfn, ien);

                if (headerResult.Success)
                {
                    if (headerResult.Note == null)
                    {
                        this.Error("Could not retrieve note data");
                    }
                    else
                    {
                        model.Note = headerResult.Note;

                        TiuNoteResult noteResult = this.DashboardRepository.Notes.GetNote(ien);

                        if (!noteResult.Success)
                        {
                            this.Error(noteResult.Message);
                        }
                        else
                        {
                            model.Note.NoteText = noteResult.Note.NoteText;
                        }
                    }
                }
                else
                {
                    this.Error(headerResult.Message);
                }
            }

            // *** Get pregnancies ***
            List <PregnancyDetails> pregList = PregnancyUtilities.GetPregnancies(this.DashboardRepository, dfn);

            // *** Get pregnancy description ***
            if (!string.IsNullOrWhiteSpace(model.Note.PregnancyIen))
            {
                foreach (PregnancyDetails preg in pregList)
                {
                    if (preg.Ien == model.Note.PregnancyIen)
                    {
                        model.PregnancyDescription = preg.Description;
                    }
                }
            }

            // *** Set default description ***
            if (string.IsNullOrWhiteSpace(model.PregnancyDescription))
            {
                model.PregnancyDescription = PregnancyUtilities.NotAssociatedMessage;
            }

            // *** Set return url ***
            if (TempData.ContainsKey(ReturnUrl))
            {
                model.ReturnUrl     = TempData[ReturnUrl].ToString();
                TempData[ReturnUrl] = TempData[ReturnUrl];
            }

            return(View(model));
        }
        public ActionResult Enroll(string dfn)
        {
            Text4BabyModel model = new Text4BabyModel();

            // *** Set patient ***
            model.Patient = this.CurrentPatient;

            // *** Add values to enrollment ***
            model.Enrollment.FirstName           = model.Patient.FirstName;
            model.Enrollment.MenstrualPeriodDate = this.CurrentPatient.Lmp;
            model.Enrollment.MobileNumber        = this.CurrentPatient.MobilePhone;
            model.Enrollment.ZipCode             = this.CurrentPatient.ZipCode;
            model.Enrollment.EmailAddress        = this.CurrentPatient.Email;

            // *** Get most recent pregnancy ***
            PregnancyResult pregResult = this.DashboardRepository.Pregnancy.GetCurrentOrMostRecentPregnancy(dfn);

            // *** Check Result ***
            if (pregResult.Success)
            {
                if (pregResult.Pregnancy != null)
                {
                    if (pregResult.Pregnancy.RecordType == PregnancyRecordType.Current)
                    {
                        // *** If current preg has EDD, add data to enrollment ***
                        if (pregResult.Pregnancy.EDD != DateTime.MinValue)
                        {
                            model.Enrollment.DueDateKnown     = true;
                            model.Enrollment.PregnancyDueDate = pregResult.Pregnancy.EDD;
                            model.Enrollment.ParticipantType  = Text4BabyParticipantType.Pregnant;
                        }
                    }
                    else
                    {
                        // *** Get the outcome type ***
                        PregnancyOutcomeType outcomeType = PregnancyUtilities.GetPregnancyOutcome(this.DashboardRepository, dfn, pregResult.Pregnancy.Ien);

                        // *** Display most recent pregnancy outcome ***
                        string outcomeMessage = string.Format("This patient's most recent pregnancy outcome: {0}", PregnancyOutcomeUtility.GetDescription(outcomeType));

                        switch (outcomeType)
                        {
                        case PregnancyOutcomeType.FullTermDelivery:
                        case PregnancyOutcomeType.PretermDelivery:
                        case PregnancyOutcomeType.Unknown:
                            model.Enrollment.ParticipantType = Text4BabyParticipantType.NewMom;
                            model.EnrollmentInfo             = outcomeMessage;
                            break;

                        default:
                            model.EnrollmentWarning = outcomeMessage;
                            break;
                        }

                        if (pregResult.Pregnancy.EndDate != DateTime.MinValue)
                        {
                            model.Enrollment.BabyDateOfBirth = pregResult.Pregnancy.EndDate;
                        }
                    }
                }
            }


            return(View(model));
        }
        public ActionResult Summary(string dfn)
        {
            // *** Create new model ***
            PatientSummary model = new PatientSummary();

            // *** Get patient demographics ***
            model.Patient = this.CurrentPatient;

            // *** Check for success ***
            if (!model.Patient.NotFound)
            {
                PregnancyResult pregResult = this.DashboardRepository.Pregnancy.GetCurrentOrMostRecentPregnancy(dfn);

                if (pregResult.Success)
                {
                    if (pregResult.Pregnancy != null)
                    {
                        if (pregResult.Pregnancy.RecordType == PregnancyRecordType.Current)
                        {
                            model.CurrentPregnancy = pregResult.Pregnancy;

                            PregnancyDetails tempDetails = PregnancyUtilities.GetPregnancyObservationData(this.DashboardRepository, dfn, model.CurrentPregnancy.Ien);

                            model.CurrentPregnancy.Lmp            = tempDetails.Lmp;
                            model.CurrentPregnancy.FetusBabyCount = tempDetails.FetusBabyCount;

                            model.CurrentPregnancy.EddBasis   = tempDetails.EddBasis;
                            model.CurrentPregnancy.EddIsFinal = tempDetails.EddIsFinal;
                        }
                        else
                        {
                            // TODO: Show most recent pregnancy ?
                        }

                        // *** Get pregnancy checklist ***
                        UpdateChecklistSummary(model, dfn, pregResult);
                    }
                }

                // *** Get Pregnancy History ***
                PregnancyHistoryResult histResult = this.DashboardRepository.Pregnancy.GetPregnancyHistory(dfn);

                if (histResult.Success)
                {
                    model.PregnancyHistory = histResult.PregnancyHistory;
                }
                else
                {
                    model.PregnancyHistory = new PregnancyHistory();
                    this.Error(histResult.Message);
                }
            }

            // *** Set return url ***
            if (TempData.ContainsKey(LastPatientListUrl))
            {
                model.ReturnUrl = TempData[LastPatientListUrl].ToString();

                TempData.Keep(LastPatientListUrl);

                // *** Indicate how to get back here ***
                TempData[ReturnUrl] = Url.Action("Summary", "Patient", new { dfn = dfn });
            }

            return(View("Summary2", model));
        }
Пример #13
0
        public ActionResult AddEdit(PatientOutcomeAddEdit model)
        {
            ActionResult returnResult = null;

            // *** Make sure patient is current ***
            this.CurrentPatientDfn = model.Patient.Dfn;
            model.Patient          = this.CurrentPatient;

            bool ok = true;

            // *** Add pregnancy record if it does not exist ***
            if (string.IsNullOrWhiteSpace(model.PregnancyIen))
            {
                PregnancyDetails newDetails = new PregnancyDetails()
                {
                    PatientDfn = this.CurrentPatientDfn, RecordType = PregnancyRecordType.Historical
                };

                IenResult saveResult = this.DashboardRepository.Pregnancy.SavePregnancy(newDetails);

                if (saveResult.Success)
                {
                    model.PregnancyIen = saveResult.Ien;
                }
                else
                {
                    this.Error(saveResult.Message);
                }
            }

            if (!string.IsNullOrWhiteSpace(model.PregnancyIen))
            {
                string normalizedOutcomeDate = "";
                if (!string.IsNullOrWhiteSpace(model.OutcomeDetails.OutcomeDate))
                {
                    normalizedOutcomeDate = VistaDates.StandardizeDateFormat(model.OutcomeDetails.OutcomeDate);
                }

                // *** Update outcome observation ***
                List <Observation> outcomeList = ObservationsFactory.CreateOutcomeObservations
                                                 (
                    model.Patient.Dfn,
                    model.OutcomeDetails.OutcomeType,
                    normalizedOutcomeDate,
                    model.PregnancyIen
                                                 );

                BrokerOperationResult obsResult = this.DashboardRepository.Observations.SaveSingletonObservations(outcomeList);

                if (!obsResult.Success)
                {
                    this.Error(obsResult.Message);
                    ok = false;
                }

                if (ok)
                {
                    if (!string.IsNullOrWhiteSpace(normalizedOutcomeDate))
                    {
                        // *** Update pregnancy end date ***
                        PregnancyDetails preg = PregnancyUtilities.GetPregnancy(this.DashboardRepository, model.Patient.Dfn, model.PregnancyIen);

                        if (preg != null)
                        {
                            // *** Update date ***
                            preg.DisplayEndDate = normalizedOutcomeDate;

                            // *** Save updated pregnancy ***
                            BrokerOperationResult savePregResult = this.DashboardRepository.Pregnancy.SavePregnancy(preg);

                            // *** Check result ***
                            if (!savePregResult.Success)
                            {
                                this.Error(savePregResult.Message);
                                ok = false;
                            }
                        }
                    }
                }

                // *** Get observations from the model ***
                ObservationConstructable details = model.OutcomeDetails.SelectedDetails;

                if (details != null)
                {
                    List <Observation> obsList = details.GetObservations(model.Patient.Dfn, model.PregnancyIen, "");

                    if (obsList != null)
                    {
                        if (obsList.Count > 0)
                        {
                            // *** If we have any, save them ***
                            BrokerOperationResult result = this.DashboardRepository.Observations.SaveSingletonObservationsByCategory(obsList);

                            if (!result.Success)
                            {
                                this.Error(result.Message);
                                ok = false;
                            }
                        }
                    }
                }
            }

            if (ok)
            {
                returnResult = RedirectToAction("PregnancyView", "Pregnancy", new { dfn = model.Patient.Dfn, pregIen = model.PregnancyIen });
            }
            else
            {
                returnResult = View(model);
            }

            return(returnResult);
        }