public MedicationHx(Patient owner)
{
theProband = owner;
Medications = new List<Medication>();
chemoprevention= new Chemoprevention(owner);
}
private void addMRIExamToolStripMenuItem_Click(object sender, EventArgs e)
{
RiskApps3.Model.PatientRecord.Patient proband = SessionManager.Instance.GetActivePatient();
if (proband != null)
{
BreastImagingStudy bis = new BreastImagingStudy();
bis.unitnum = proband.unitnum;
bis.type = "MRI";
bis.date = DateTime.Today;
bis.imagingType = "MRI";
bis.side = "Bilateral";
AddImagingForm aif = new AddImagingForm();
aif.Text = "Add new MRI Study";
aif.study = bis;
aif.proband = proband;
if (aif.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
int a = SessionManager.Instance.GetActivePatient().apptid;
string u = SessionManager.Instance.GetActivePatient().unitnum;
FinalizeRecordForm frm = new FinalizeRecordForm(a, u);
frm.ShowDialog();
RefreshQueue();
}
}
}
public EditComments(Patient patient)
{
this.InitializeComponent();
this._patient = patient;
this.commentsTextBox.Text = patient.Patient_Comment;
this._oldComments = patient.Patient_Comment;
}
private void CommunicationTimeline_Load(object sender, EventArgs e)
{
SessionManager.Instance.NewActivePatient += NewActivePatient;
proband = SessionManager.Instance.GetActivePatient();
if (proband != null)
proband.AddHandlersWithLoad(null, activePatientLoaded, null);
}
private void button4_Click(object sender, EventArgs e)
{
RiskApps3.Model.PatientRecord.Patient p = SessionManager.Instance.GetActivePatient();
if (p != null)
{
p.Tasks.AddHandlersWithLoad(null, TaskListLoaded, null);
}
}
/**************************************************************************************************/
private void PendingTasksSummaryView_Load(object sender, EventArgs e)
{
SessionManager.Instance.NewActivePatient += NewActivePatient;
proband = SessionManager.Instance.GetActivePatient();
if (proband != null)
proband.AddHandlersWithLoad(null, activePatientLoaded, null);
}
public SurveyResponse(Patient proband, int surveyID, string responseTag, string responseValue, string comment)
: this(proband)
{
//this.apptID = proband.apptid;
this.surveyID = surveyID;
this.responseTag = responseTag;
this.responseValue = responseValue;
this.comment = comment;
}
/**************************************************************************************************/
private void InitActivePatient()
{
// get active patinet object from session manager
proband = SessionManager.Instance.GetActivePatient();
fastDataListView1.Enabled = false;
loadingCircle1.Enabled = true;
loadingCircle1.Visible = true;
proband.RP.NCCNGuideline.AddHandlersWithLoad(NCCNChanged, NCCNLoaded, NCCNItemChanged);
}
private static int GetrefPCPProviderId(RA.Patient patient)
{
return(0);
/*
* if (patient.Providers.Count > 0 && patient.Providers.FirstOrDefault(p => p.PCP == true) != null)
* return patient.Providers.FirstOrDefault(p => p.PCP == true).providerID;
* else return 0;
*/
}
/**************************************************************************************************/
private void NewActivePatient(object sender, NewActivePatientEventArgs e)
{
flowLayoutPanel1.Enabled = false;
if (proband != null)
proband.ReleaseListeners(this);
proband = e.newActivePatient;
proband.AddHandlersWithLoad(null, activePatientLoaded, null);
}
/**************************************************************************************************/
private void InitNewPatient()
{
// get active patinet object from session manager
proband = SessionManager.Instance.GetActivePatient();
if (proband != null)
{
proband.AddHandlersWithLoad(activePatientChanged,activePatientLoaded,null);
}
}
/**************************************************************************************************/
private void NewActivePatient(object sender, NewActivePatientEventArgs e)
{
//ClearControls();
if (proband != null)
proband.ReleaseListeners(this);
if (e.newActivePatient != null)
{
proband = e.newActivePatient;
proband.AddHandlersWithLoad(null, activePatientLoaded, null);
}
}
private void TaskListLoadedForPopup(HraListLoadedEventArgs e)
{
RiskApps3.Model.PatientRecord.Patient p = SessionManager.Instance.GetActivePatient();
if (p != null)
{
Task t = new Task(p, "Task", "Pending", SessionManager.Instance.ActiveUser.ToString(), DateTime.Now);
HraModelChangedEventArgs args = new HraModelChangedEventArgs(null);
args.Persist = true;
p.Tasks.AddToList(t, args);
TaskView tv = new TaskView(t);
tv.ShowDialog();
p.Tasks.ReleaseListeners(this);
RefreshQueue();
}
}
/**************************************************************************************************/
private void InitSelectedRelative()
{
proband = SessionManager.Instance.GetActivePatient();
if (proband != null)
{
proband.AddHandlersWithLoad(activePatientChanged, activePatientLoaded, null);
pedGen = new PedigreeGenerator(pictureBox1.Width, pictureBox1.Height);
pedGen.showBrcaScores = showBrcaScores;
pedGen.showMmrScores = showMmrScores;
Bitmap b = pedGen.GeneratePedigreeImage();
pictureBox1.Image = b;
}
}
/**************************************************************************************************/
private void InitNewPatient()
{
// get active patient object from session manager
proband = SessionManager.Instance.GetActivePatient();
ClearControls();
if (proband != null)
{
loadingCircle1.Visible = true;
loadingCircle1.Enabled = true;
label1.Visible = false;
proband.AddHandlersWithLoad(activePatientChanged, activePatientLoaded, null);
}
}
/// <summary>
/// User for new appointment.
/// </summary>
/// <param name="mrn"></param>
/// <param name="clinicId">clinic to default to when opening wizard</param>
public AddAppointmentView(string mrn, int? clinicId)
: this()
{
this._mode = Mode.Add;
InitializeModeConditions();
this._patient = new Patient(mrn);
this._patient.Providers.LoadFullList();
SessionManager.Instance.SetActivePatient(this._patient.unitnum, this._patient.apptid);
this._appointment = new Appointment (clinicId, mrn) { ClinicList = this._clinics};
this._clinicId = clinicId;
MarkStartedAndPullForwardForm mark = new MarkStartedAndPullForwardForm(this._appointment.apptID, this._appointment.unitnum);
mark.ShowDialog();
}
public void setPatient(Patient proband)
{
if (proband != null)
{
PCP.Text = "";
if (patient != null)
{
patient.ReleaseListeners(this);
patient.Providers.ReleaseListeners(this);
}
patient = proband;
Providers = patient.Providers;
if (patient != null)
{
patient.AddHandlersWithLoad(activePatientChanged, activePatientLoaded, null);
patient.Providers.AddHandlersWithLoad(null, ProvidersLoaded, null);
}
}
else
{
PatientName.Text = "";
HomePhone.Text = "";
age.Text = "";
MRN.Text = "";
CellPhone.Text = "";
DOB.Text = "";
WorkPhone.Text = "";
PCP.Text = "";
if (patient != null)
{
patient.ReleaseListeners(this);
patient.Providers.ReleaseListeners(this);
}
patient = proband;
}
}
public static Appointment FromRAppointment(this Appointment appt, RA.Patient patient)
{
appt.Address1 = patient.address1;
appt.Address2 = patient.address2;
appt.Cellphone = patient.cellphone;
appt.City = patient.city;
appt.Country = patient.country;
appt.Education = patient.educationLevel;
appt.EmailAddress = patient.emailAddress;
appt.Gender = patient.gender;
appt.Homephone = patient.homephone;
appt.Maritalstatus = patient.maritalstatus;
appt.Occupation = patient.occupation;
appt.Patient_Comment = patient.comment;//mapping needs to verify
appt.RefPhysician = GetrefPhysProviderId(patient);
appt.PCP = GetrefPCPProviderId(patient);
appt.State = patient.state;
appt.Workphone = patient.workphone;
appt.Zip = patient.zip;
return(appt);
}
private void TaskListLoaded(HraListLoadedEventArgs e)
{
RiskApps3.Model.PatientRecord.Patient p = SessionManager.Instance.GetActivePatient();
if (p != null)
{
string assignedBy = "";
if (SessionManager.Instance.ActiveUser != null)
{
if (string.IsNullOrEmpty(SessionManager.Instance.ActiveUser.ToString()) == false)
{
assignedBy = SessionManager.Instance.ActiveUser.ToString();
}
}
Task t = new Task(p, "Task", "Pending", assignedBy, DateTime.Now);
HraModelChangedEventArgs args = new HraModelChangedEventArgs(null);
args.Persist = true;
p.Tasks.AddToList(t, args);
TaskView tv = new TaskView(t);
tv.ShowDialog();
p.Tasks.ReleaseListeners(this);
RefreshQueue();
}
}
public PedigreeGenerator(int Width, int Height, Patient proband)
{
height = Height;
width = Width;
//pedigreeControl1 = new PedigreeControl();
pedigreeControl1 = new PedigreeControl(false);
pedigreeLegend1 = new PedigreeLegend();
pedigreeComment1 = new PedigreeComment();
pedigreeTitleBlock1 = new PedigreeTitleBlock();
sysDefaultAnnotations = new PedigreeAnnotationList("-1");
sysDefaultAnnotations.BackgroundListLoad();
pedigreeSettingsForm1 = new PedigreeSettingsForm(sysDefaultAnnotations);
if (proband != null)
{
if (proband.guiPreferences.Count == 0)
{
GUIPreference gp = new GUIPreference();
gp.BackgroundLoadWork();
proband.guiPreferences.Add(gp);
}
}
}
public void ConsumeSettings(GUIPreference preferences)
{
switch (this.PrefSubtype)
{
case Subtype.Normal:
this.owningPatient = preferences.owningPatient;
this.parentName = preferences.parentName;
this.formName = preferences.formName;
break;
case Subtype.System:
this.owningPatient = null;
this.parentName = "System";
this.formName = "Default";
break;
case Subtype.User:
this.owningPatient = null;
this.parentName = SessionManager.Instance.ActiveUser.userLogin;
this.formName = "Default";
break;
default:
this.owningPatient = preferences.owningPatient;
this.parentName = preferences.parentName;
this.formName = preferences.formName;
break;
}
this.modifiedDate = DateTime.Now;
this.width = preferences.width;
this.height = preferences.height;
this.pedigreeZoomValue = preferences.pedigreeZoomValue;
this.pedigreeVerticalSpacing = preferences.pedigreeVerticalSpacing;
this.ShowRelIds = preferences.ShowRelIds;
this.PedigreeBackground = preferences.PedigreeBackground;
this.nameWidth = preferences.nameWidth;
this.limitedEthnicity = preferences.limitedEthnicity;
this.ShowTitle = preferences.ShowTitle;
this.ShowName = preferences.ShowName;
this.NameFont = preferences.NameFont;
this.ShowUnitnum = preferences.ShowUnitnum;
this.UnitnumFont = preferences.UnitnumFont;
this.ShowDob = preferences.ShowDob;
this.DobFont = preferences.DobFont;
this.TitleBackground = preferences.TitleBackground;
this.TitleBorder = preferences.TitleBorder;
this.ShowLegend = preferences.ShowLegend;
this.LegendBackground = preferences.LegendBackground;
this.LegendBorder = preferences.LegendBorder;
this.LegendRadius = preferences.LegendRadius;
this.LegendFont = preferences.LegendFont;
this.ShowComment = preferences.ShowComment;
this.CommentBackground = preferences.CommentBackground;
this.CommentBorder = preferences.CommentBorder;
this.CommentFont = preferences.CommentFont;
this.LegendX = preferences.LegendX;
this.LegendY = preferences.LegendY;
this.LegendHeight = preferences.LegendHeight;
this.LegendWidth = preferences.LegendWidth;
this.TitleX = preferences.TitleX;
this.TitleY = preferences.TitleY;
this.TitleHeight = preferences.TitleHeight;
this.TitleWidth = preferences.TitleWidth;
this.CommentX = preferences.CommentX;
this.CommentY = preferences.CommentY;
this.CommentHeight = preferences.CommentHeight;
this.CommentWidth = preferences.CommentWidth;
this.VariantFoundText = preferences.VariantFoundText;
this.VariantFoundVusText = preferences.VariantFoundVusText;
this.VariantNotFoundText = preferences.VariantNotFoundText;
this.VariantUnknownText = preferences.VariantUnknownText;
this.VariantNotTestedText = preferences.VariantNotTestedText;
this.VariantHeteroText = preferences.VariantHeteroText;
this.hideNonBloodRelatives = preferences.hideNonBloodRelatives;
foreach (PedigreeAnnotation pa in annotations)
{
foreach (PedigreeAnnotation target in preferences.annotations)
{
if (pa.annotation == target.annotation)
{
if (pa.area != target.area)
{
pa.area = target.area;
pa.slot = target.slot;
pa.SignalModelChanged(new HraModelChangedEventArgs(null));
}
break;
}
}
}
SignalModelChanged(new HraModelChangedEventArgs(null));
}
private static bool processAsRiskFactorClinicalObservation(string hra_tag, ref Patient targetPatient, string coAgeDx, string statusCode, string coValue)
{
bool retval = true;
switch (hra_tag)
{
case "startedMenstruating":
targetPatient.ObGynHx.ObGynHistory_startedMenstruating = coAgeDx;
break;
case "ageFirstChildBorn":
targetPatient.ObGynHx.ObGynHistory_ageFirstChildBorn = coAgeDx;
break;
case "Colonoscopy":
targetPatient.SocialHx.colonoscopyLast10Years = HL7FormatTranslator.GetColonoscopyType(statusCode);
break;
case "Colon Polyp-NOS":
targetPatient.SocialHx.colonPolypLast10Years = HL7FormatTranslator.GetColonPolypType(statusCode); ;
break;
case "Number of breast biopsies":
targetPatient.procedureHx.breastBx.BreastBx_breastBiopsies = coValue;
break;
case "Menopausal Status":
HL7FormatTranslator.DecodeMenopausalStatus(statusCode, ref targetPatient.ObGynHx);
break;
case "Menopause Age":
targetPatient.ObGynHx.ObGynHistory_stoppedMenstruating = coAgeDx;
break;
case "Height":
targetPatient.PhysicalExam.PhysicalExamination_heightInches = HL7FormatTranslator.GetInchesFromMeters(coValue);
targetPatient.PhysicalExam.PhysicalExamination_heightFeetInches = HL7FormatTranslator.GetFeetInchesFromMeters(coValue);
break;
case "Weight":
targetPatient.PhysicalExam.PhysicalExamination_weightPounds = HL7FormatTranslator.GetPoundsFromKg(coValue);
break;
case "HRT Use":
targetPatient.ObGynHx.ObGynHistory_hormoneUse = HL7FormatTranslator.GetHRTUse(statusCode);
break;
case "HRT Type":
targetPatient.ObGynHx.ObGynHistory_hormoneCombined = HL7FormatTranslator.GetHRTType(statusCode);
break;
case "HRT Length Past":
if (coValue != "-99")
{
targetPatient.ObGynHx.ObGynHistory_hormoneUseYears = coValue;
}
break;
case "HRT Length Intent":
if (coValue != "-99")
{
targetPatient.ObGynHx.ObGynHistory_hormoneIntendedLength = coValue;
}
break;
case "HRT Last Use":
if (coValue != "-99")
{
targetPatient.ObGynHx.ObGynHistory_hormoneYearsSinceLastUse = coValue;
}
break;
case "Vigorous Exercise hours per week":
targetPatient.SocialHx.vigorousPhysicalActivityHoursPerWeek = HL7FormatTranslator.GetExcersizeType(statusCode);
break;
case "Cigarette Smoking years":
targetPatient.SocialHx.SocialHistory_numYearsSmokedCigarettes = coValue;
break;
case "Cigarettes per day":
targetPatient.SocialHx.SocialHistory_numCigarettesPerDay = coValue;
break;
case "Vegetable servings per day":
targetPatient.SocialHx.vegetableServingsPerDay = HL7FormatTranslator.GetVegetablesType(statusCode);
break;
case "Aspirin or NSAID regular use":
targetPatient.SocialHx.RegularAspirinUser = statusCode;
break;
case "Ibuprofen regular use":
targetPatient.SocialHx.RegularIbuprofenUser = statusCode;
break;
default:
retval = false;
break;
}
return retval;
}
/**************************************************************************************************/
public CDSBreastOvary(Patient owner)
{
patientOwning = owner;
}
/**************************************************************************************************/
private void NewActivePatient(object sender, NewActivePatientEventArgs e)
{
ClearControls();
patientRecordHeader1.setPatient(SessionManager.Instance.GetActivePatient());
loadingCircle1.Visible = true;
loadingCircle1.Enabled = true;
if (proband != null)
proband.ReleaseListeners(this);
proband = e.newActivePatient;
if (proband != null)
{
Enabled = true;
proband.AddHandlersWithLoad(null, activePatientLoaded, null);
backgroundWorker1.RunWorkerAsync();
}
else
{
Enabled = false;
}
}
/**************************************************************************************************/
internal void ClearActivePatient()
{
activePatient = null;
selectedRelative = null;
if (NewActivePatient != null)
NewActivePatient(this, new NewActivePatientEventArgs(activePatient,securityContext));
}
/**************************************************************************************************/
public void SetActivePatientNoCallback(string unitnum, int apptid)
{
activePatient = new Patient(unitnum);
activePatient.apptid = apptid;
selectedRelative = (Person)activePatient;
if (activePatient.HraState != HraObject.States.Ready)
{
activePatient.BackgroundLoadWork();
activePatient.HraState = HraObject.States.Ready;
}
}
/**************************************************************************************************/
public void SetActivePatient(string unitnum, int apptid)
{
if (activePatient != null)
{
activePatient.ReleaseListeners(this);
activePatient.Tasks.ReleaseListeners(this);
}
activePatient = new Patient(unitnum);
activePatient.apptid = apptid;
selectedRelative = (Person)activePatient;
if (HttpContext.Current == null) // Silicus: LoadObject has Async calls.
activePatient.LoadObject();
if (NewActivePatient != null)
NewActivePatient(this, new NewActivePatientEventArgs(activePatient, securityContext));
RelativeSelectedEventArgs args = new RelativeSelectedEventArgs(selectedRelative, securityContext);
if (RelativeSelected != null)
RelativeSelected(args);
}
/// <summary>
/// For normal usage
/// </summary>
public GUIPreference(Patient proband, DateTime GUIPreference_modifiedDate, string GUIPreference_formName, string GUIPreference_parentName, int GUIPreference_width, int GUIPreference_height, bool readOnly = false)
: this(proband, readOnly)
{
modifiedDate = GUIPreference_modifiedDate;
formName = GUIPreference_formName;
parentName = GUIPreference_parentName;
width = GUIPreference_width;
height = GUIPreference_height;
ConsumeSettings(SessionManager.Instance.MetaData.SystemWideDefaultPedigreePrefs);
owningPatient = proband;
}
public GUIPreference(Patient proband, bool readOnly = false)
{
this.ReadOnly = readOnly;
this.PrefSubtype = Subtype.Normal;
annotations = new PedigreeAnnotationList(proband.unitnum);
owningPatient = proband;
}
/**************************************************************************************************/
private void PatientCommunicationView_Load(object sender, EventArgs e)
{
//this.winFormHtmlEditor1.BtnImage.Click += winFormHtmlEditor1_BtnImage_Click;
winFormHtmlEditor1.ToolbarItemOverrider.ImageButtonClicked += winFormHtmlEditor1_BtnImage_Click;
winFormHtmlEditor1.EditorMode = SpiceLogic.HtmlEditorControl.Domain.BOs.EditorModes.ReadOnly_Preview;
htmlEditorPanel.Visible = false;
NoPreviewPanel.Visible = false;
if (!ViewClosing)
{
SessionManager.Instance.NewActivePatient += NewActivePatient;
proband = SessionManager.Instance.GetActivePatient();
if (proband != null)
{
proband.AddHandlersWithLoad(null, activePatientLoaded, null);
loadingCircle1.Enabled = true;
loadingCircle1.Visible = true;
}
else
{
Enabled = false;
}
}
try
{
string dicPath = Environment.GetEnvironmentVariable("appdata") + @"\microsoft\uproof";
if (Directory.Exists(dicPath))
{
foreach (string s in Directory.GetFiles(dicPath, "*.dic", SearchOption.TopDirectoryOnly))
{
winFormHtmlEditor1.SpellCheckOptions.DictionaryFile.UserDictionaryFilePath = s;
}
}
}
catch (Exception ex)
{
Logger.Instance.WriteToLog(ex.ToString());
}
}
public NewActivePatientEventArgs(Patient p_newActivePatient, SecurityContext p_securityContext)
: base(null)
{
newActivePatient = p_newActivePatient;
}
public FamilyHistoryViewSerializer(Patient p, Model.PatientRecord.FHx.FamilyHistory f)
{
InitializeComponent();
this.fhx = f;
this.proband = p;
}
private void xmlExport(string fileName, Patient patient, bool deIdentify)
{
patient.LoadFullObject();
FamilyHistory theFH = patient.owningFHx;
if (!deIdentify)
{
//legacy code chunk; written before caring about de-identifying
DataContractSerializer ds = new DataContractSerializer(typeof(FamilyHistory));
FileStream stm = new FileStream(fileName, FileMode.Create);
ds.WriteObject(stm, theFH);
stm.Flush();
stm.Position = 0;
stm.Close();
return;
}
// De-Identify the XML data by using a transform, then save the file
string fhAsString = TransformUtils.DataContractSerializeObject<FamilyHistory>(theFH);
//transform it
XmlDocument inDOM = new XmlDocument();
inDOM.LoadXml(fhAsString);
string toolsPath = Configurator.AssemblyDirectory; //since project is built with xsl file as linked project member, xsl s/b in the executing folder, whereever that is
XmlDocument resultXmlDoc = TransformUtils.performTransform(inDOM, toolsPath, @"hraDeIdentifySerialized.xsl");
//following actually removes all indentation and extra whitespace; prefer to save the file with indentations, so leave this commented
//hl7FHData.PreserveWhitespace = true;
resultXmlDoc.Save(fileName);
}
/// <summary>
/// For use with system default meta data construction
/// </summary>
public GUIPreference(bool readOnly = false)
{
this.ReadOnly = readOnly;
this.PrefSubtype = Subtype.System;
owningPatient = null;
parentName = "System";
formName = "Default";
annotations = new PedigreeAnnotationList("-1");
//annotations.BackgroundListLoad();
}
/**************************************************************************************************/
private void InitNewPatient()
{
// get active patient object from session manager
proband = SessionManager.Instance.GetActivePatient();
if (proband != null)
{
proband.breastImagingHx.AddHandlersWithLoad(theBreastImagingHxChanged, theBreastImagingHxLoaded, DiagnosticChanged);
proband.transvaginalImagingHx.AddHandlersWithLoad(theTransvaginalImagingHxChanged, theTransvaginalImagingHxLoaded, DiagnosticChanged);
proband.labsHx.AddHandlersWithLoad(theLabsChanged, theLabsLoaded, DiagnosticChanged);
//patientSummaryHeader1.InitNewPatient();
}
}
/// <summary>
/// For use with user default meta data contruction
/// </summary>
/// <param name="u"></param>
/// <param name="readOnly">should this object be locked against db persistance?</param>
public GUIPreference(User u, bool readOnly = false)
{
this.ReadOnly = readOnly;
this.PrefSubtype = Subtype.User;
annotations = new PedigreeAnnotationList("-1");
owningPatient = null;
parentName = u.userLogin;
formName = "Default";
}