using framework_business;
using framework_library;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class controls_medical_procedures : System.Web.UI.UserControl
{
    #region methods

    /// <summary>
    /// Method to Bind Procedure Data
    /// </summary>
    private void BindProcedureData()
    {
        try
        {
            ArrayList ProcedureList = xData.GetTypedByCriteriaSpecific("recId", typeof(oMedicalProcedure), "", "", "code");
            rptProcedures.DataSource = ProcedureList;
            rptProcedures.DataBind();
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    private void BindMacroProcedures()
    {
        try
        {
            ddMacroProcedure.Items.Clear();
            ddMacroProcedure.ClearSelection();
            DataTable ProcedureList = xData.GetDynamicTable("recId", typeof(oMedicalProcedure), "code");
            for (int i = ProcedureList.Rows.Count - 1; i >= 0; i--)
            {
                if (ProcedureList.Rows[i]["codeType"].ToString() == "3")
                    ProcedureList.Rows.RemoveAt(i);
            }
            ProcedureList.Columns.Add(new DataColumn("TextField", System.Type.GetType("System.String"), "code + ' - ' + description"));
            ddMacroProcedure.DataSource = ProcedureList;
            ddMacroProcedure.DataTextField = "TextField";
            ddMacroProcedure.DataValueField = "recId";
            ddMacroProcedure.DataBind();

            ddMacroProcedure_SelectedIndexChanged(null, null);
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }


    /// <summary>
    /// Method to Bind Tariff Data
    /// </summary>
    private void BindTariffs()
    {
        try
        {
            ArrayList tariffs = xData.GetTypedByCriteriaSpecific("recId", typeof(oTariffPlan), "", "", "name");
            ddTariffPlans.DataSource = tariffs;
            ddTariffPlans.DataValueField = "code";
            ddTariffPlans.DataTextField = "name";
            ddTariffPlans.DataBind();


        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Populate Form Values
    /// </summary>
    /// <param name="_Procedure"></param>
    private void PopulatePageFormValues(ref oMedicalProcedure _Procedure)
    {
        try
        {
            txtCode.Value = _Procedure.code;
            txtDescription.Value = _Procedure.description;
            txtAbbreviation.Value = _Procedure.procedureAbbreviation;
            ddCodeTypes.SelectedValue = _Procedure.codeType.ToString();
            txtComments.Value = _Procedure.comments;
            txtNAPPI.Value = _Procedure.nappi;
            txtNAPPISuffix.Value = _Procedure.nappiSuffix;

            txtICD1.Value = _Procedure.icd1;
            txtICD2.Value = _Procedure.icd2;
            txtICD3.Value = _Procedure.icd3;
            txtICD4.Value = _Procedure.icd4;
            chkClaimActive.Checked = _Procedure.claimActive;
            chkNonSurgical.Checked = _Procedure.nonSurgical;

            /* CVH 2016-09-30 Set additional description (tendon) */
            chkAdditionalDescription.Checked = _Procedure.additionalDescription;

            if (_Procedure.codeType == 2)//modifier
            {
                txtModifier.Value = utils.returnFormattedDecimal(Convert.ToString(_Procedure.modifier));
            }
            else
                txtModifier.Value = "0";

            if (_Procedure.codeType == 1)//consumable
            {
                if (_Procedure.consumableCode != String.Empty)
                    ddConsumableCode.SelectedValue = _Procedure.consumableCode;
            }

            else
                _Procedure.consumableCode = String.Empty;

            //CVH 2016-11-11 Load macro procedures
            DataTable dt = new DataTable();
            dt.Columns.Add("id");
            dt.Columns.Add("procedureId");
            dt.Columns.Add("description");
            dt.Columns.Add("quantity");
            dt.Columns.Add("rate");
            if (_Procedure.codeType == 3)//macro
            {
                chkUseMacroRate.Checked = _Procedure.useMacroRate;
                foreach (string macro in _Procedure.macroProcedures.Split(','))
                {
                    string[] macroArray = macro.Split('|');
                    if (macroArray.Length == 3)
                    {
                        string procedureId = macroArray[0];
                        string qty = macroArray[1];
                        string rate = macroArray[2];
                        string description = "";
                        if (ddMacroProcedure.Items.FindByValue(procedureId) != null)
                        {
                            description = ddMacroProcedure.Items.FindByValue(procedureId).Text;
                        }

                        DataRow row = dt.NewRow();
                        row["id"] = dt.Rows.Count;
                        row["procedureId"] = procedureId;
                        row["description"] = description;
                        row["quantity"] = qty;
                        row["rate"] = rate;
                        dt.Rows.Add(row);
                    }
                }
                Session["Macro"] = dt;
            }
            rptMacroProcedures.DataSource = dt;
            rptMacroProcedures.DataBind();
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save Form Values
    /// </summary>
    /// <param name="_Procedure"></param>
    private void SavePageFormValues(ref oMedicalProcedure _Procedure)
    {
        try
        {
            _Procedure.code = txtCode.Value;
            _Procedure.description = txtDescription.Value;
            _Procedure.procedureAbbreviation = txtAbbreviation.Value;
            _Procedure.codeType = int.Parse(ddCodeTypes.SelectedValue);
            _Procedure.comments = txtComments.Value;
            _Procedure.nappi = txtNAPPI.Value;
            _Procedure.nappiSuffix = txtNAPPISuffix.Value;
            _Procedure.stockType = int.Parse(ddCodeTypes.SelectedValue);
            _Procedure.icd1 = txtICD1.Value;
            _Procedure.icd2 = txtICD2.Value;
            _Procedure.icd3 = txtICD3.Value;
            _Procedure.icd4 = txtICD4.Value;
            _Procedure.claimActive = chkClaimActive.Checked;
            _Procedure.nonSurgical = chkNonSurgical.Checked;

            /* CVH 2016-09-30 Set additional description (tendon) */
            _Procedure.additionalDescription = chkAdditionalDescription.Checked;
            //hardcode list of tendons now, tendons are the only additional description required currently. if there are more at a later stage this can be handled better
            if (_Procedure.additionalDescription)
                _Procedure.additionalDescriptionOptions = "Subscapularis~Supraspinatus~Infraspinatus~Teres minor";
            else
                _Procedure.additionalDescriptionOptions = "";

            if (_Procedure.codeType == 2)//modifier
            {
                decimal mod = 0;
                decimal.TryParse(txtModifier.Value, out mod);
                _Procedure.modifier = mod;
            }
            else
                _Procedure.modifier = 0;

            if (_Procedure.codeType == 1)//consumable
                _Procedure.consumableCode = ddConsumableCode.SelectedValue;
            else
                _Procedure.consumableCode = String.Empty;

            //CVH 2016-11-11 Save macro procedures
            string macroProcedures = String.Empty;
            if (_Procedure.codeType == 3)//macro
            {
                _Procedure.useMacroRate = chkUseMacroRate.Checked;
                if (utils.verifySession("Macro"))
                {
                    DataTable dt = (DataTable)Session["Macro"];
                    if (dt != null)
                    {
                        foreach (DataRow row in dt.Rows)
                        {
                            string procedureId = row["procedureId"].ToString();
                            int qty = 0;
                            int.TryParse(row["quantity"].ToString(), out qty);
                            decimal rate = 0;
                            decimal.TryParse(row["rate"].ToString(), out rate);
                            if (macroProcedures == String.Empty)
                                macroProcedures = procedureId + "|" + (qty < 1 ? 1 : qty) + "|" + rate;
                            else
                                macroProcedures += "," + procedureId + "|" + (qty < 1 ? 1 : qty) + "|" + rate;
                        }
                    }
                }
            }
            _Procedure.macroProcedures = macroProcedures;
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Method to Toggle Panels
    /// </summary>
    /// <param name="panelName"></param>
    private void TogglePanels(string panelName)
    {
        switch (panelName)
        {
            case "pnlProcedurePage":

                pnlProcedurePage.Visible = true;
                pnlProcedureList.Visible = false;
                break;
            case "pnlProcedureList":
                pnlProcedurePage.Visible = false;
                pnlProcedureList.Visible = true;
                break;
        }

        //clear result
        pnlResult.Visible = false;
    }

    /// <summary>
    /// opulate the rate from the tariff
    /// </summary>
    private void populateRateFromTariff()
    {
        try
        {
            if (ddTariffPlans.SelectedValue != null && ddTariffPlans.SelectedValue != "" && txtCode.Value != String.Empty)
            {
                string planCode = ddTariffPlans.SelectedValue;
                foreach (oTariffRate rate in xData.GetTypedByCriteriaSpecific("recId", typeof(oTariffRate), "planCode,procedureCode", planCode + "," + txtCode.Value))
                {
                    txtRate.Value = utils.returnFormattedDecimal(Convert.ToString(rate.rate));
                    break;
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Set display based on selected code type
    /// </summary>
    private void SetCodeTypeDisplay()
    {
        try
        {
            chkUseMacroRate.Visible = false;

            switch (ddCodeTypes.SelectedValue)
            {
                case "0"://service item
                    pnlConsumable.Visible = false;
                    pnlModifier.Visible = false;
                    pnlMakroProcedures.Visible = false;
                    break;
                case "1"://consumable
                    pnlConsumable.Visible = true;
                    pnlModifier.Visible = false;
                    pnlMakroProcedures.Visible = false;
                    break;
                case "2"://modifier
                    pnlConsumable.Visible = false;
                    pnlModifier.Visible = true;
                    pnlMakroProcedures.Visible = false;
                    break;
                case "3"://macro
                    pnlConsumable.Visible = false;
                    pnlModifier.Visible = false;
                    pnlMakroProcedures.Visible = true;
                    chkUseMacroRate.Visible = true;                    
                    break;
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }


    #endregion

    #region events

    /// <summary>
    /// Page Load Event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
        try
        {
            if (!Page.IsPostBack)
            {
                BindProcedureData();
                BindTariffs();
            }

        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// New Procedure Click
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnNewProcedure_Click(object sender, EventArgs e)
    {
        try
        {
            utils.disposeSession("Macro");

            //show Content Specific
            TogglePanels("pnlProcedurePage");
            Session["ProcedureId"] = 0;
            utils.disposeSession("Procedure");
            oMedicalProcedure Procedure = new oMedicalProcedure();
            BindMacroProcedures();
            PopulatePageFormValues(ref Procedure);
            txtCode.Disabled = false;
            pnlRates.Visible = false;
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }


    /// <summary>
    /// Edit the Procedure page
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkEdit_Click(object sender, EventArgs e)
    {
        oMedicalProcedure _Procedure = new oMedicalProcedure();
        ArrayList catList = new ArrayList();
        try
        {
            if (sender.GetType() == typeof(LinkButton))
            {
                //
                int recId = int.Parse(((LinkButton)sender).CommandArgument);
                if (recId > 0)
                {
                    Session["ProcedureId"] = recId;
                    //get cat
                    catList = xData.GetTypedByCriteriaSpecific("recId", typeof(oMedicalProcedure), "recId", recId.ToString());
                    //enumerate list
                    foreach (oMedicalProcedure cat in catList)
                    {
                        //assign object
                        _Procedure = cat;
                        //populate page form
                        BindMacroProcedures();
                        PopulatePageFormValues(ref _Procedure);
                        populateRateFromTariff();
                        SetCodeTypeDisplay();
                        txtCode.Disabled = true;
                        pnlRates.Visible = true;
                        Session["Procedure"] = _Procedure;
                        break;
                    }

                    //show Procedure Form
                    TogglePanels("pnlProcedurePage");
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Remove the Procedure
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkRemove_Click(object sender, EventArgs e)
    {
        try
        {
            if (sender.GetType() == typeof(LinkButton))
            {
                int recId = int.Parse(((LinkButton)sender).CommandArgument);
                foreach (oMedicalProcedure proc in xData.GetTypedByCriteriaSpecific("recId", typeof(oMedicalProcedure), "recId", recId.ToString()))
                {
                    //delete rates for this procedure
                    if (xData.DeleteTyped("procedureCode", proc.code, typeof(oTariffRate)))
                    {
                        //Delete fee
                        if (xData.DeleteTyped("recId", recId.ToString(), typeof(oMedicalProcedure)))
                        {
                            //rebind pages grid
                            BindProcedureData();
                            pnlResult.Visible = true;
                            //display successful result
                            lblResult.Text = "the selected Procedure was deleted successfully.";
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Cancel
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnCancel_Click(object sender, EventArgs e)
    {
        try
        {
            Session["ProcedureId"] = 0;
            utils.disposeSession("Procedure");
            utils.disposeSession("Macro");

            BindProcedureData();
            //show cat list
            TogglePanels("pnlProcedureList");
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save Click
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSave_Click(object sender, EventArgs e)
    {
        oMedicalProcedure Procedure = new oMedicalProcedure();
        try
        {
            if (utils.verifySession("Procedure"))//update mode
            {
                Procedure = (oMedicalProcedure)Session["Procedure"];

                //save form values
                SavePageFormValues(ref Procedure);
                if (xData.UpdateTyped("recId", Procedure.recId.ToString(), typeof(oMedicalProcedure), Procedure))
                {
                    Session["ProcedureId"] = Procedure.recId;
                    Session["Procedure"] = Procedure;

                    BindProcedureData();
                    pnlResult.Visible = true;
                    lblResult.Text = "your changes were updated successfully.";
                }
            }
            else
            {
                if (!xData.VerifyExists("recId", typeof(oMedicalProcedure), "code", txtCode.Value))
                {
                    //save form values
                    SavePageFormValues(ref Procedure);


                    //save procedure
                    Procedure.recId = xData.SaveTyped("recId", typeof(oMedicalProcedure), Procedure);
                    if (Procedure.recId > 0)
                    {
                        //create rates for procedure
                        ArrayList Plans = xData.GetTypedByCriteriaSpecific("recId", typeof(oTariffPlan), "", "", "code");
                        ArrayList Rates = new ArrayList();
                        foreach (oTariffPlan pln in Plans)
                        {
                            oTariffRate rate = new oTariffRate();
                            rate.planCode = pln.code;
                            rate.procedureCode = Procedure.code;
                            rate.rate = 0;
                            Rates.Add(rate);
                        }
                        if (Rates.Count > 0)
                        {
                            //save rates
                            xData.SaveTypedCollection("recId", typeof(oTariffRate), Rates);
                        }
                        Session["ProcedureId"] = Procedure.recId;
                        Session["Procedure"] = Procedure;

                        BindProcedureData();

                        pnlRates.Visible = true;
                        pnlResult.Visible = true;
                        lblResult.Text = "your Procedure was created successfully.";
                        txtCode.Disabled = true;
                    }


                }
                else
                {
                    pnlResult.Visible = true;
                    lblResult.Text = "A Procedure with this code already exists on the system";
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Selected Index Changed Event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void ddCodeTypes_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            SetCodeTypeDisplay();
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Selected Index Changed Event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void ddTariffPlans_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            populateRateFromTariff();
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Apply Rate changes
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnApplyRate_Click(object sender, EventArgs e)
    {
        try
        {
            decimal rate = 0;
            decimal.TryParse(txtRate.Value, out rate);
            if (ddTariffPlans.Items.Count > 0)
            {
                if (chkApplyRate.Checked)//apply rate to all plans for this code
                {
                    if (xData.UpdateRates("", txtCode.Value, rate))
                    {
                        lblRateResult.Text = "All plans were updated.";
                    }
                }
                else
                {
                    if (xData.UpdateRates(ddTariffPlans.SelectedValue, txtCode.Value, rate))
                    {
                        lblRateResult.Text = "Plan successfully updated.";
                    }
                }
            }

        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }


    protected void btnAddMacroProcedure_Click(object sender, EventArgs e)
    {
        try
        {
            if (ddMacroProcedure.SelectedItem != null)
            {
                DataTable dt = new DataTable();
                if (utils.verifySession("Macro"))
                    dt = (DataTable)Session["Macro"];

                if (dt.Columns.Count <= 0)
                {
                    dt.Columns.Add("id");
                    dt.Columns.Add("procedureId");
                    dt.Columns.Add("description");
                    dt.Columns.Add("quantity");
                    dt.Columns.Add("rate");
                }

                string procedureId = ddMacroProcedure.SelectedItem.Value;
                string description = ddMacroProcedure.SelectedItem.Text;
                int qty = 0;
                int.TryParse(txtMacroQty.Text, out qty);
                qty = (qty <= 0 ? 1 : qty);

                decimal rate = 0;
                decimal.TryParse(txtMacroRate.Text, out rate);

                //modifiers can be added to a macro only once 0005 0018 0011 0014 0009 0008
                bool modifierExists = false;
                if (description.StartsWith("0005 -") || description.StartsWith("0018 -") ||
                    description.StartsWith("0011 -") || description.StartsWith("0014 -") ||
                    description.StartsWith("0009 -") || description.StartsWith("0008 -"))
                {
                    if (!description.StartsWith("0011 -"))
                        qty = 1;

                    foreach (DataRow chkExists in dt.Rows)
                    {
                        if (chkExists["procedureId"].ToString() == procedureId)
                        {
                            modifierExists = true;
                            break;
                        }
                    }
                }

                if (!modifierExists)
                {
                    DataRow newRow = dt.NewRow();
                    newRow["id"] = dt.Rows.Count;
                    newRow["procedureId"] = procedureId;
                    newRow["description"] = description;
                    newRow["quantity"] = qty;
                    newRow["rate"] = rate;
                    dt.Rows.Add(newRow);
                }

                Session["Macro"] = dt;

                rptMacroProcedures.DataSource = dt;
                rptMacroProcedures.DataBind();
                btnAddMacroProcedure.Text = "Add";
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    protected void lnkRemoveMacro_Click(object sender, EventArgs e)
    {
        try
        {
            LinkButton btn = (LinkButton)sender;
            if (btn != null)
            {
                int id = int.Parse(btn.CommandArgument);
                if (utils.verifySession("Macro"))
                {
                    DataTable dt = (DataTable)Session["Macro"];
                    if (dt != null)
                    {
                        for (int i = dt.Rows.Count - 1; i >= 0; i--)
                        {
                            if (dt.Rows[i]["id"].ToString() == id.ToString())
                            {
                                dt.Rows.RemoveAt(i);
                                break;
                            }
                        }
                    }

                    Session["Macro"] = dt;
                    rptMacroProcedures.DataSource = dt;
                    rptMacroProcedures.DataBind();
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    protected void ddMacroProcedure_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            if (ddMacroProcedure.SelectedItem != null)
            {
                string procedureId = ddMacroProcedure.SelectedItem.Value;
                foreach (oMedicalProcedure proc in xData.GetTypedByCriteriaSpecific("recId", typeof(oMedicalProcedure), "recId", procedureId))
                {
                    foreach (oTariffRate rate in xData.GetTypedByCriteriaSpecific("recId", typeof(oTariffRate), "planCode,procedureCode", "DISC," + proc.code))
                    {
                        txtMacroRate.Text = rate.rate.ToString();
                    }
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }
    }

    protected void lnkEditMacro_Click(object sender, EventArgs e)
    {
        try
        {
            LinkButton btn = (LinkButton)sender;
            if (btn != null)
            {
                int id = int.Parse(btn.CommandArgument);
                if (utils.verifySession("Macro"))
                {
                    DataTable dt = (DataTable)Session["Macro"];
                    if (dt != null)
                    {
                        for (int i = dt.Rows.Count - 1; i >= 0; i--)
                        {
                            if (dt.Rows[i]["id"].ToString() == id.ToString())
                            {
                                txtMacroQty.Text = dt.Rows[i]["quantity"].ToString();
                                txtMacroRate.Text = dt.Rows[i]["rate"].ToString();
                                ddMacroProcedure.Items.FindByValue(dt.Rows[i]["procedureId"].ToString());
                                btnAddMacroProcedure.Text = "Re-Add";
                                dt.Rows.RemoveAt(i);
                                break;
                            }
                        }
                    }

                    Session["Macro"] = dt;
                    rptMacroProcedures.DataSource = dt;
                    rptMacroProcedures.DataBind();
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("Procedure:", MethodBase.GetCurrentMethod().Name, ex, Session["Procedure"]);
            Response.Redirect("/error", false);
        }

    }


    #endregion


}