private static string ResultBuilder(MdsCheckFinalResult result, ErrorBase error)
        {
            StringBuilder sBuilder = new StringBuilder();

            sBuilder.AppendLine(error.errorDesc);
            sBuilder.AppendLine(error.errorCause.IsNullOrWhiteSpace() ? string.Empty : error.errorCause);
            sBuilder.AppendLine(error.errorAction.IsNullOrWhiteSpace() ? string.Empty : error.errorAction);
            sBuilder.AppendLine();

            return(sBuilder.ToString());
        }
        private void btnMDSCheckResult_Click(object sender, EventArgs e)
        {
            MdsCheckFinalResult source = currentMdsResultForShow;

            try
            {
                var dialog = new MDDCheckDialogBox(source, "Clinical Intervention");

                dialog.ShowDialog(this);
                //new MDSDialog(source).ShowDialog();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        public MDDCheckDialogBox(MdsCheckFinalResult mds, string SubTitle)
        {
            InitializeComponent();
            lblSubTitle.Text = SubTitle;
            lblCaution.Text  = "CAUTION for " + mds.DrugName;

            cmdYes.Visible = true;
            cmdNo.Visible  = false;
            cmdYes.Text    = "OK";

            for (int i = mds.MdsCheckAlertDetails.Count - 1; i >= 0; i--)
            {
                for (int j = mds.MdsCheckAlertDetails[i].CheckAlerts.Count - 1; j >= 0; j--)
                {
                    var currentItem = mds.MdsCheckAlertDetails[i].CheckAlerts[j];

                    var Glabel = new GrowLabel();
                    Glabel.Text      = currentItem.CheckAlertMessage;
                    Glabel.Dock      = DockStyle.Top;
                    Glabel.Font      = new Font("Segoe UI", 10, FontStyle.Bold);
                    Glabel.TextAlign = ContentAlignment.BottomLeft;
                    pnlCheckList.Controls.Add(Glabel);

                    var rTxt = new RichTextBoxEx(currentItem.CheckingDrugName, currentItem.CheckingDrugName + currentItem.CheckingDrugSuffix);
                    rTxt.Dock           = DockStyle.Top;
                    rTxt.Font           = new Font("Segoe UI", 10, FontStyle.Bold);
                    rTxt.SelectionColor = Color.Blue;
                    pnlCheckList.Controls.Add(rTxt);
                }

                var lkLabel = new TextBox();
                lkLabel.Text        = mds.MdsCheckAlertDetails[i].CategoryName;
                lkLabel.Dock        = DockStyle.Top;
                lkLabel.Font        = new Font("Segoe UI", 10, FontStyle.Underline | FontStyle.Bold);
                lkLabel.TextAlign   = HorizontalAlignment.Left;
                lkLabel.BorderStyle = BorderStyle.None;
                pnlCheckList.Controls.Add(lkLabel);
            }

            this.TransparencyKey = Color.Azure;
            //lblSubTitle.ForeColor = this.pnlIcon.BackColor;
            Type(this, 40, 0.06);
            this.TopMost = true;
        }
Example #4
0
        private MdsCheckFinalResult InitalData()
        {
            var initSource = new MdsCheckFinalResult();

            initSource.DrugName = "ASPRIN";

            initSource.MdsCheckAlertDetails.Add(new MdsCheckAlert("Allergy Checking",
                                                                  new List <MdsCheckAlertContent> {
                new MdsCheckAlertContent
                {
                    CheckingDrugName   = "ASPRIN",
                    CheckingDrugSuffix = " Allergy history reported",
                    CheckAlertMessage  = @"Clinical Manifestation: Rash: Urticaria 
    Additional information: TEST 1 
    Level of Certainty: Certain 
    Use of ASPIRIN TABLET may result in allergic reaction."
                }
            }
                                                                  ));

            /*
             *          initSource.MdsCheckAlertDetails.Add(new MdsCheckAlert("G6PD Deficiency Contraindication Checking",
             *              @"ASPIRIN TABLET is contraindicated when Hemolytic Anemia from Pyruvate Kinase and G6PD Deficientcies, a condition related to G6PD Deficiency, exists."));
             *
             *          initSource.MdsCheckAlertDetails.Add(new MdsCheckAlert("Adverse Drug Reaction Checking",
             *              @"ASPIRIN - Adverse drug reaction hisotry reported
             * Adverse Drug Reaction: Abdomial Pain With Cramps; Heartburn
             * Level of Severity: Severe
             * Use of ASPIRIN TABLET may result in adverse drug reaction."));
             */


            //  var str = string.Format(@"ASPIRIN - Adverse drug reaction hisotry reported{0}Adverse Drug Reaction: Abdomial Pain With Cramps; Heartburn{0}Level of Severity: Severe", Environment.NewLine);


            //   initSource.MdsCheckAlertDetails.Add(new MdsCheckAlert("JERIFFE TEST", str));

            return(initSource);
        }
        /// <summary>
        /// to generate final MDS check message
        /// </summary>
        /// <param name="mdsResult"></param>
        /// <param name="drugName"></param>
        /// <returns></returns>
        public static MdsCheckFinalResult ToConvert(this MDSCheckResult mdsResult, string drugName)
        {
            MdsCheckFinalResult resultForShow = new MdsCheckFinalResult();

            resultForShow.DrugName = drugName;
            #region system error
            if (false == string.IsNullOrEmpty(mdsResult.errorDesc))
            {
                resultForShow.SystemErrorMessage += mdsResult.errorDesc + Environment.NewLine;
            }
            if (mdsResult.allergyError != null && mdsResult.allergyError.hasAllergyError)
            {
                resultForShow.SystemErrorMessage += ResultBuilder(resultForShow, mdsResult.allergyError);
            }
            if (mdsResult.adrError != null && mdsResult.adrError.hasAdrError)
            {
                resultForShow.SystemErrorMessage += ResultBuilder(resultForShow, mdsResult.adrError);
            }
            if (mdsResult.drugError != null && mdsResult.drugError.hasDrugError)
            {
                resultForShow.SystemErrorMessage += ResultBuilder(resultForShow, mdsResult.drugError);
            }
            #endregion

            #region allergy alert message
            if (mdsResult.drugAllergyCheckingResults != null && mdsResult.drugAllergyCheckingResults.hasDrugAllergyAlert)
            {
                resultForShow.HasMdsAlert = true;
                foreach (var allergyMsg in mdsResult.drugAllergyCheckingResults.drugAllergyAlerts)
                {
                    /*
                     * 1 Clinical Manifestations will be delimited by semicolon ";", if the last clinical manifestation is equal to additional information, system should hide the additional information field.
                     * 2 System should reconstruct the alert message if the following keyword is found in the message:
                     * Sequence of keyword matching	If the following keywords found in [drugAllergyAlertMessages]	Replace the message by the following message
                     * 1	an allergic/a cross-sensitivity	Use of uppercase[drugDdimDisplayName from 2.5.1] may result in allergic/cross-sensitivity reaction.
                     * 2	an idiosyncratic	Use of uppercase[drugDdimDisplayName from 2.5.1] may result in idiosyncratic reaction.
                     * 3	an allergic	Use of uppercase[drugDdimDisplayName from 2.5.1] may result in allergic reaction.
                     * 4	a cross-sensitivity	Use of uppercase[drugDdimDisplayName from 2.5.1] may result in cross-sensitivity reaction.
                     */

                    allergyMsg.drugAllergyAlertMessage = WrapperAllergyCheckResultMessage(drugName, allergyMsg.drugAllergyAlertMessage);

                    allergyMsg.manifestation.TrimEnd(new char[] { ';' });

                    StringBuilder sbuilder = new StringBuilder();
                    sbuilder.AppendLine(string.Format("{0} - Allergy history reported", allergyMsg.allergen));
                    sbuilder.AppendLine(string.Format("Clinical Manifestation: {0}", allergyMsg.manifestation));
                    sbuilder.AppendLine(string.Format("Additional Information: {0}", allergyMsg.remark));
                    sbuilder.AppendLine(string.Format("Level of Certainty: {0}", allergyMsg.certainty));
                    sbuilder.AppendLine(allergyMsg.drugAllergyAlertMessage);

                    //   resultForShow.MdsCheckAlertDetails.Add(new MdsCheckAlert("Allergy Checking", sbuilder.ToString()));
                }
            }
            #endregion

            #region ddcm alert (G6PD alert)
            if (mdsResult.ddcmCheckingResults != null && mdsResult.ddcmCheckingResults.hasDdcmAlert)
            {
                foreach (string ddcmAlert in mdsResult.ddcmCheckingResults.ddcmAlertMessages)
                {
                    //  resultForShow.MdsCheckAlertDetails.Add(new MdsCheckAlert("G6PD Deficiency Contraindication Checking", ddcmAlert));
                }
            }
            #endregion

            #region adr alert
            if (mdsResult.drugAdrCheckingResults != null && mdsResult.drugAdrCheckingResults.hasDrugAdrAlert)
            {
                foreach (DrugAdrAlert adrAlert in mdsResult.drugAdrCheckingResults.drugAdrAlerts)
                {
                    adrAlert.reaction.TrimEnd(new char[] { ';' });

                    adrAlert.drugAdrAlertMessage = WrapperAdrCheckResultAlertMessage(drugName, adrAlert.drugAdrAlertMessage);

                    StringBuilder sbuilder = new StringBuilder();
                    sbuilder.AppendLine(string.Format("{0} - Adverse drug reaction history reported", drugName));
                    sbuilder.AppendLine(string.Format("Adverse Drug Reaction: {0}", adrAlert.reaction));
                    sbuilder.AppendLine(string.Format("Additional Information: {0}", adrAlert.remark));
                    sbuilder.AppendLine(string.Format("Level of Certainty: {0}", adrAlert.severity));
                    sbuilder.AppendLine(adrAlert.drugAdrAlertMessage);

                    //  resultForShow.MdsCheckAlertDetails.Add(new MdsCheckAlert("Adverse Drug Reaction Checking", sbuilder.ToString()));
                }
            }
            #endregion

            return(resultForShow);
        }
        private void bgWorkerMDSCheck_DoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                var itemCode = e.Argument as string;

                var patientCache = FullCacheHK.PataientCache[CASE_NUMBER];

                currentMdsResultForShow = parser.MDSCheck(new InventoryObj { Billnum = itemCode, CommonName = itemCode },
                    CASE_NUMBER,
                    patientCache.PatientDemoEnquiry,
                    patientCache.AlertProfileRes);

                this.BeginInvoke((MethodInvoker)delegate
                {
                    try
                    {
                        if (FullCacheHK.PataientCache[CASE_NUMBER] != null)
                        {
                            if (FullCacheHK.PataientCache[CASE_NUMBER].MDSCache[itemCode] == null)
                            {
                                ResetMDSReqRes();

                                return;
                            }

                            var mds = FullCacheHK.PataientCache[CASE_NUMBER].MDSCache[itemCode];

                            if (mds.DrugMdsPropertyHqReq != null)
                            {
                                scintillaDrugMdsPropertyHqReq.Text = XmlHelper.XmlSerializeToString(mds.DrugMdsPropertyHqReq);
                                scintillaDrugMdsPropertyHqRes.Text = XmlHelper.XmlSerializeToString(mds.DrugMdsPropertyHqRes);
                            }

                            if (mds.PreparationReq != null)
                            {
                                scintillaDrugPreparationReq.Text = XmlHelper.XmlSerializeToString(mds.PreparationReq);
                                scintillaDrugPreparationRes.Text = XmlHelper.XmlSerializeToString(mds.PreparationRes);
                            }

                            if (mds.Res != null)
                            {
                                var requestXml = XmlHelper.XmlSerializeToString(mds.Req);
                                scintillaMdsCheckReq.Text = requestXml;

                                var resultJson = JsonHelper.ToJson(mds.Res);
                                scintillaMdsCheckRes.Text = JsonHelper.FormatJson(resultJson);
                            }
                        }

                        if (currentMdsResultForShow.HasMdsAlert)
                        {
                            btnMDSCheckResult.Enabled = true;
                        }
                        else
                        {
                            btnMDSCheckResult.Enabled = false;
                        }
                    }
                    catch (Exception ex)
                    {

                        ex = ex;
                    }

                });
            }
            catch (Exception EX)
            {
                EX = EX;
            }

        }