Beispiel #1
0
    /// <summary>
    /// method
    /// loads items in the specified collection into the ddl
    /// </summary>
    /// <param name="Data"></param>
    /// <param name="ddl"></param>
    /// <param name="lItemID"></param>
    /// <returns></returns>
    public static CStatus LoadItemCollectionDDL(
        CData Data,
        DropDownList ddl,
        long lItemID)
    {
        CItemCollectionData coll   = new CItemCollectionData(Data);
        DataSet             dsColl = null;
        CStatus             status = coll.GetItemCollectionDS(lItemID, out dsColl);

        if (!status.Status)
        {
            return(status);
        }

        status = CDropDownList.RenderDataSet(
            dsColl,
            ddl,
            "item_label",
            "item_id");
        if (!status.Status)
        {
            return(status);
        }

        return(new CStatus());
    }
    /// <summary>
    /// US:1883
    /// override
    /// loads the control with the items of the collection specified by the LongID property
    /// </summary>
    /// <param name="lEditMode"></param>
    /// <returns></returns>
    public override CStatus LoadControl(k_EDIT_MODE lEditMode)
    {
        EditMode = lEditMode;

        if (EditMode == k_EDIT_MODE.UPDATE)
        {
            CItemCollectionData itemCollection = new CItemCollectionData(BaseMstr.BaseData);
            DataSet             ds             = null;
            CStatus             status         = itemCollection.GetItemCollectionDS(LongID, out ds);
            if (!status.Status)
            {
                return(status);
            }

            CollectionItems             = ds.Tables[0];
            gvItemCollection.DataSource = CollectionItems;
            gvItemCollection.DataBind();
        }
        else
        {
            LongID = 0;
            gvItemCollection.DataSource = null;
            gvItemCollection.DataBind();
            InitializeDataTable();
        }

        return(new CStatus());
    }
Beispiel #3
0
    /// <summary>
    /// US:1945 US:1883
    /// method
    /// deletes all the component/collection records that are not supported by the item's type
    /// </summary>
    /// <param name="lItemID"></param>
    /// <param name="lItemTypeID"></param>
    /// <param name="strItemComponentIDs"></param>
    /// <param name="strItemIDs"></param>
    /// <returns></returns>
    public CStatus DeleteChildren(long lItemID, long lItemTypeID, string strItemComponentIDs, string strItemIDs)
    {
        CItemComponentData  ic             = new CItemComponentData(this);
        CItemCollectionData itemCollection = new CItemCollectionData(this);
        CStatus             status         = null;

        switch (lItemTypeID)
        {
        case (long)k_ITEM_TYPE_ID.Laboratory:
            status = ic.DeleteItemComponentStates(lItemID, string.Empty);
            if (!status.Status)
            {
                return(status);
            }
            break;

        case (long)k_ITEM_TYPE_ID.QuestionSelection:
            status = ic.DeleteItemComponentRanges(lItemID, string.Empty);
            if (!status.Status)
            {
                return(status);
            }
            break;

        case (long)k_ITEM_TYPE_ID.QuestionFreeText:
        case (long)k_ITEM_TYPE_ID.NoteTitle:
        case (long)k_ITEM_TYPE_ID.Collection:
            status = ic.DeleteItemComponentRanges(lItemID, string.Empty);
            if (!status.Status)
            {
                return(status);
            }

            status = ic.DeleteItemComponentStates(lItemID, string.Empty);
            if (!status.Status)
            {
                return(status);
            }
            break;

        default:
            return(new CStatus(false, k_STATUS_CODE.Failed, "TODO"));
        }

        status = itemCollection.DeleteItemCollection(lItemID, strItemIDs);
        if (!status.Status)
        {
            return(status);
        }

        status = ic.DeleteItemComponents(lItemID, strItemComponentIDs);
        if (!status.Status)
        {
            return(status);
        }

        return(new CStatus());
    }
Beispiel #4
0
    /// <summary>
    /// US:1883
    /// override
    /// loads the control with the values of the patient item specified
    /// by the properties CollectionItemID and PatientID
    /// </summary>
    /// <param name="lEditMode"></param>
    /// <returns></returns>
    public override CStatus LoadControl(k_EDIT_MODE lEditMode)
    {
        EditMode = lEditMode;

        tbCollection.Text = string.Empty;

        CItemCollectionData ItemCollection = new CItemCollectionData(BaseMstr.BaseData);
        DataSet             dsItems        = null;
        CStatus             status         = ItemCollection.GetItemColMostRecentPatItemDS(CollectionItemID, PatientID, out dsItems);

        if (!status.Status)
        {
            return(status);
        }

        DataSet dsItemComps = null;

        status = ItemCollection.GetItemColMostRecentPatICDS(CollectionItemID, PatientID, out dsItemComps);
        if (!status.Status)
        {
            return(status);
        }

        foreach (DataRow drItem in dsItems.Tables[0].Rows)
        {
            tbCollection.Text += drItem["ITEM_LABEL"].ToString() + "\r\n";
            DataRow[] draComponents = dsItemComps.Tables[0].Select("ITEM_ID = " + drItem["ITEM_ID"].ToString());
            foreach (DataRow drComponent in draComponents)
            {
                if (Convert.ToInt64(drItem["ITEM_TYPE_ID"]) == (long)k_ITEM_TYPE_ID.QuestionSelection)
                {
                    // skip non selected items
                    if (drComponent["COMPONENT_VALUE"].ToString() == Convert.ToInt64(k_TRUE_FALSE_ID.False).ToString())
                    {
                        continue;
                    }

                    tbCollection.Text += drComponent["ITEM_COMPONENT_LABEL"].ToString() + "\r\n";
                }
                else
                {
                    tbCollection.Text += drComponent["ITEM_COMPONENT_LABEL"].ToString() + "\r\n";
                    tbCollection.Text += drComponent["COMPONENT_VALUE"].ToString() + "\r\n";
                }
            }
            tbCollection.Text += "\r\n";
        }

        return(new CStatus());
    }
    /// <summary>
    /// US:1883
    /// override
    /// saves the item collection to the database
    /// </summary>
    /// <returns></returns>
    public override CStatus SaveControl()
    {
        CStatus status = DeleteChildItems();

        if (!status.Status)
        {
            return(status);
        }

        foreach (DataRow dr in CollectionItems.Rows)
        {
            CItemCollectionDataItem di = new CItemCollectionDataItem();
            di.CollectionItemID = Convert.ToInt64(dr["COLLECTION_ITEM_ID"]);
            di.ItemID           = Convert.ToInt64(dr["ITEM_ID"]);
            di.SortOrder        = Convert.ToInt64(dr["SORT_ORDER"]);

            CItemCollectionData itemCollection = new CItemCollectionData(BaseMstr.BaseData);
            if (di.CollectionItemID < 1)
            {
                di.CollectionItemID = LongID;
                status = itemCollection.InsertItemCollection(di);
                if (!status.Status)
                {
                    return(status);
                }

                dr["COLLECTION_ITEM_ID"] = LongID;
            }
            else
            {
                status = itemCollection.UpdateItemCollection(di);
                if (!status.Status)
                {
                    return(status);
                }
            }
        }



        return(new CStatus());
    }
Beispiel #6
0
    /// <summary>
    /// runs logic for a collection item this is na for now!
    /// too many issues to do this. ON hOLD!
    /// </summary>
    /// <param name="strPatientID"></param>
    /// <param name="lPatCLID"></param>
    /// <param name="lChecklistID"></param>
    /// <param name="lItemID"></param>
    /// <returns></returns>
    public CStatus RunCollectionLogic(string strPatientID,
                                      long lPatCLID,
                                      long lChecklistID,
                                      long lItemID)
    {
        CStatus status = new CStatus();

        DataSet dsColItems = null;

        CItemCollectionData icd = new CItemCollectionData(this);

        icd.GetItemCollectionDS(lItemID, out dsColItems);
        foreach (DataRow drItem in dsColItems.Tables[0].Rows)
        {
            try
            {
                //get the item type id
                long lColItemID = Convert.ToInt64(drItem["ITEM_ID"]);

                long             lSummaryStateID = -1;
                CPatientItemData pid             = new CPatientItemData(this);
                pid.GetMostRecentPICSummaryStateID(strPatientID,
                                                   lColItemID,
                                                   out lSummaryStateID);

                CPatientItemDataItem di = null;
                pid.GetMostRecentPatientItemDI(strPatientID,
                                               lColItemID,
                                               out di);
            }
            catch (Exception)
            {
                return(new CStatus(
                           false,
                           k_STATUS_CODE.Failed,
                           LogicModuleMessages.ERROR_RUN_LOGIC));
            }
        }

        return(status);
    }
Beispiel #7
0
    /// <summary>
    /// method
    /// US:902
    /// runs the logic for the specified patient checklist if it is open
    /// </summary>
    /// <param name="lPatCLID"></param>
    /// <returns></returns>
    public CStatus RunLogic(long lPatCLID)
    {
        CPatChecklistData     pcl = new CPatChecklistData(this);
        CPatChecklistDataItem di  = null;
        CStatus status            = pcl.GetPatChecklistDI(lPatCLID, out di);

        if (!status.Status)
        {
            return(status);
        }

        if (di.ChecklistStateID != k_CHECKLIST_STATE_ID.Open)
        {
            return(new CStatus());
        }

        DataSet dsChecklistItems   = null;
        CPatChecklistItemData pcli = new CPatChecklistItemData(this);

        status = pcli.GetPatCLItemsByPatCLIDDS(lPatCLID, out dsChecklistItems);
        if (!status.Status)
        {
            return(status);
        }

        foreach (DataRow drItem in dsChecklistItems.Tables[0].Rows)
        {
            try
            {
                //get the item type id
                long   lItemTypeID     = Convert.ToInt64(drItem["ITEM_TYPE_ID"]);
                string strPatientID    = drItem["PATIENT_ID"].ToString();
                long   lPatChecklistID = Convert.ToInt64(drItem["PAT_CL_ID"]);
                long   lChecklistID    = Convert.ToInt64(drItem["CHECKLIST_ID"]);
                long   lItemID         = Convert.ToInt64(drItem["ITEM_ID"]);

                CExpressionList expList = new CExpressionList(
                    this,
                    drItem["PATIENT_ID"].ToString(),
                    Convert.ToInt64(drItem["PAT_CL_ID"]),
                    Convert.ToInt64(drItem["CHECKLIST_ID"]),
                    Convert.ToInt64(drItem["ITEM_ID"]));

                status = expList.Load(drItem["LOGIC"].ToString());
                if (!status.Status)
                {
                    return(status);
                }

                //run the default logic for the collection
                if (lItemTypeID == (long)k_ITEM_TYPE_ID.Collection)
                {
                    CItemCollectionData ColData = new CItemCollectionData(this);
                    status = ColData.RunCollectionLogic(strPatientID,
                                                        lPatChecklistID,
                                                        lChecklistID,
                                                        lItemID);
                    if (!status.Status)
                    {
                        return(status);
                    }
                }

                //run custom logic for the item
                status = expList.Evaluate();
                if (!status.Status)
                {
                    return(status);
                }
            }
            catch (Exception)
            {
                return(new CStatus(
                           false,
                           k_STATUS_CODE.Failed,
                           LogicModuleMessages.ERROR_RUN_LOGIC));
            }
        }

        return(new CStatus());
    }
Beispiel #8
0
    /// <summary>
    /// load a gridview value row
    /// </summary>
    /// <param name="gvr"></param>
    protected void LoadGridViewValue(GridViewRow gvr)
    {
        if (gvr == null)
        {
            return;
        }

        Panel pnlComponents = (Panel)gvr.FindControl("pnlComponents");
        Panel pnlViewValue  = (Panel)gvr.FindControl("pnlViewValue");

        if (pnlComponents == null || pnlViewValue == null)
        {
            return;
        }

        //hide the components, show the value view
        pnlComponents.Visible = false;
        pnlViewValue.Visible  = true;

        //literal that holds status info
        Literal litHiddenCollValues = (Literal)gvr.FindControl("litHiddenCollValues");

        litHiddenCollValues.Text = String.Empty;

        //button to expand/collapse
        Button btnShowHiddenCollValues = (Button)gvr.FindControl("btnShowHiddenCollValues");

        //get the gridview data row
        DataRowView drv = (DataRowView)gvr.DataItem;
        DataRow     dr  = drv.Row;

        //get the item type is and item id
        long lItemTypeID = Convert.ToInt64(dr["ITEM_TYPE_ID"]);
        long lItemID     = Convert.ToInt64(dr["ITEM_ID"]);

        //hide the expand/collapse if this is not a collection
        if (lItemTypeID != (long)k_ITEM_TYPE_ID.Collection)
        {
            AjaxControlToolkit.CollapsiblePanelExtender cpe = (AjaxControlToolkit.CollapsiblePanelExtender)gvr.FindControl("cpeHiddenCollValues");
            cpe.CollapseControlID = null;
            cpe.Enabled           = false;

            btnShowHiddenCollValues.Visible = false;
        }

        //if this is a collection, build a status summary list of each ite,
        if (lItemTypeID == (long)k_ITEM_TYPE_ID.Collection)
        {
            btnShowHiddenCollValues.Visible = true;

            //get all the patient item components in the collection
            CItemCollectionData coll           = new CItemCollectionData(BaseMstr.BaseData);
            DataSet             dsPatItemComps = null;
            coll.GetItemColMostRecentPatICDS(lItemID, PatientID, out dsPatItemComps);

            //get all the items in the collection
            DataSet dsColl = null;
            CStatus status = coll.GetItemCollectionDS(lItemID, out dsColl);

            //html to hold the status
            StringBuilder sbItemCompCollHTML = new StringBuilder();

            //loop over all the items in the collection and build html
            foreach (DataTable tableColl in dsColl.Tables)
            {
                foreach (DataRow drColl in tableColl.Rows)
                {
                    //get values from the the item in the collection (not the patient items, the collection items)
                    long lActiveID   = CDataUtils.GetDSLongValue(drColl, "ACTIVE_ID");
                    long lCollItemID = CDataUtils.GetDSLongValue(drColl, "ITEM_ID");

                    //get the item so we can check entry date against TS etc...
                    CPatientItemDataItem patItemDI = null;
                    CPatientItemData     patData   = new CPatientItemData(BaseMstr.BaseData);
                    patData.GetMostRecentPatientItemDI(PatientID, lCollItemID, out patItemDI);

                    //only interested in ACTIVE items
                    if ((k_ACTIVE)lActiveID == k_ACTIVE.ACTIVE)
                    {
                        //image for state open the img tag
                        sbItemCompCollHTML.Append("<img alt=\"");
                        //sbItemCompCollHTML.Append(CDataUtils.GetDSStringValue(dr, "ITEM_LABEL"));
                        sbItemCompCollHTML.Append(" Collection Item State Image\" width=\"10\" height=\"10\" src=\"");

                        //get the current state of the item
                        k_STATE_ID lItemStateID = GetItemStateID(lItemID, lCollItemID, dsPatItemComps, patItemDI);

                        //add a red/green/yellow image based on the state of the item
                        if (lItemStateID == k_STATE_ID.Unknown ||
                            lItemStateID == k_STATE_ID.NotSelected)
                        {
                            sbItemCompCollHTML.Append(Resources.Images.STATE_UNKNOWN_SMALL);
                        }
                        else if (lItemStateID == k_STATE_ID.Good)
                        {
                            sbItemCompCollHTML.Append(Resources.Images.STATE_GOOD_SMALL);
                        }
                        else
                        {
                            sbItemCompCollHTML.Append(Resources.Images.STATE_BAD_SMALL);
                        }

                        //close out the image tag
                        sbItemCompCollHTML.Append("\" />");

                        //label, trunc so it displays nicely
                        string strLabel = CDataUtils.GetDSStringValue(drColl, "ITEM_LABEL");
                        if (strLabel.Length > 28)
                        {
                            strLabel = strLabel.Substring(0, 28) + "...";
                        }

                        //add the label after the image
                        sbItemCompCollHTML.Append(strLabel);

                        //add a line break
                        sbItemCompCollHTML.Append("<br>");
                    }
                }
            }

            //set the literal equal to the generated html
            litHiddenCollValues.Text = sbItemCompCollHTML.ToString();

            //enable the show/hide button
            btnShowHiddenCollValues.Enabled = (String.IsNullOrEmpty(litHiddenCollValues.Text)) ? false : btnShowHiddenCollValues.Enabled;
        }
    }
    /// <summary>
    /// method to run logic over a colletion
    ///     1. all items in multi select must be have an option selected
    ///     2. all free text items must have data entered
    ///     3. labs and note titles are ignored
    ///     4. items that are not ACTIVE are ignored
    /// </summary>
    public CStatus RunCollectionLogic(string strPatientID,
                                      long lPatChecklistID,
                                      long lChecklistID,
                                      long lCollectionItemID)
    {
        //Get the patient checklist item data
        CPatChecklistItemData     PatChecklistItem = new CPatChecklistItemData(this);
        CPatChecklistItemDataItem pdi = null;

        PatChecklistItem.GetPatCLItemDI(lPatChecklistID,
                                        lCollectionItemID,
                                        out pdi);

        //get all the items in the collection
        CItemCollectionData coll   = new CItemCollectionData(this);
        DataSet             dsColl = null;
        CStatus             status = coll.GetItemCollectionDS(lCollectionItemID, out dsColl);

        //get all the patient item components in the collection
        DataSet dsPatItemComps = null;

        status = coll.GetItemColMostRecentPatICDS(lCollectionItemID, strPatientID, out dsPatItemComps);

        //if this collection item is overridden just return and don't update the state
        if (pdi.IsOverridden == k_TRUE_FALSE_ID.True)
        {
            bool bReturn = true;

            //check to see if there is a new result and override if there is...
            foreach (DataTable tableI in dsColl.Tables)
            {
                foreach (DataRow drI in tableI.Rows)
                {
                    //get values from the the item in the collection (not the patient items, the collection items)
                    long lItemID     = CDataUtils.GetDSLongValue(drI, "ITEM_ID");
                    long lItemTypeID = CDataUtils.GetDSLongValue(drI, "ITEM_TYPE_ID");
                    long lActiveID   = CDataUtils.GetDSLongValue(drI, "ACTIVE_ID");

                    //get the item so we can check entry date against TS etc...
                    CPatientItemDataItem patItemDI = null;
                    CPatientItemData     patData   = new CPatientItemData(this);
                    patData.GetMostRecentPatientItemDI(strPatientID, lItemID, out patItemDI);
                    DateTime dtEntryDate = patItemDI.EntryDate;

                    if (dtEntryDate > pdi.OverrideDate)
                    {
                        pdi.OverrideDate = CDataUtils.GetNullDate();
                        pdi.IsOverridden = k_TRUE_FALSE_ID.False;
                        PatChecklistItem.UpdatePatChecklistItem(pdi);
                        bReturn = false;
                        break;
                    }
                }
            }

            if (bReturn)
            {
                //return if this item is overridden and there are no new results
                return(new CStatus());
            }
        }

        //get the checklist item di
        CChecklistItemDataItem cidDI = null;
        CChecklistItemData     cid   = new CChecklistItemData(this);

        cid.GetCLItemDI(lChecklistID, lCollectionItemID, out cidDI);

        //calculate how far the TS can go back
        long     lTS         = cidDI.CLITSTimePeriod;
        DateTime dtNow       = DateTime.Now;
        DateTime dtTSCompare = dtNow.AddDays(-1 * lTS);

        //keeps the overall OS state of the items
        k_STATE_ID kOverallOSStateID = k_STATE_ID.NotSelected;

        //keeps the overall TS state of the items
        k_STATE_ID kOverallTSStateID = k_STATE_ID.NotSelected;

        //loop over the collection items
        foreach (DataTable table in dsColl.Tables)
        {
            foreach (DataRow dr in table.Rows)
            {
                //get values from the the item in the collection (not the patient items, the collection items)
                long lItemID     = CDataUtils.GetDSLongValue(dr, "ITEM_ID");
                long lItemTypeID = CDataUtils.GetDSLongValue(dr, "ITEM_TYPE_ID");
                long lActiveID   = CDataUtils.GetDSLongValue(dr, "ACTIVE_ID");

                //get the item so we can check entry date against TS etc...
                CPatientItemDataItem patItemDI = null;
                CPatientItemData     patData   = new CPatientItemData(this);
                patData.GetMostRecentPatientItemDI(strPatientID, lItemID, out patItemDI);
                DateTime dtEntryDate = patItemDI.EntryDate;

                //only interested in ACTIVE items
                if ((k_ACTIVE)lActiveID == k_ACTIVE.ACTIVE)
                {
                    //check the TS and set overall TS state
                    k_COMPARE kTS = CDataUtils.CompareDates(dtEntryDate, dtTSCompare);
                    if (kTS == k_COMPARE.GREATERTHAN ||
                        kTS == k_COMPARE.EQUALTO)
                    {
                        //good
                        if (kOverallTSStateID != k_STATE_ID.Bad)
                        {
                            kOverallTSStateID = k_STATE_ID.Good;
                        }
                    }
                    else
                    {
                        //bad
                        kOverallTSStateID = k_STATE_ID.Bad;
                    }

                    //list to hold the created component items
                    CPatientItemCompList PatItemCompList = new CPatientItemCompList();

                    //build a pat item component list loaded with the most recent
                    //values
                    foreach (DataTable tableComp in dsPatItemComps.Tables)
                    {
                        foreach (DataRow drComp in tableComp.Rows)
                        {
                            //values to load the component item
                            long   lCompItemID       = CDataUtils.GetDSLongValue(drComp, "ITEM_ID");
                            long   lComponentID      = CDataUtils.GetDSLongValue(drComp, "ITEM_COMPONENT_ID");
                            string strComponentValue = CDataUtils.GetDSStringValue(drComp, "COMPONENT_VALUE");
                            long   lPatItemID        = CDataUtils.GetDSLongValue(drComp, "PAT_ITEM_ID");
                            //only this item
                            if (lCompItemID == lItemID)
                            {
                                CPatientItemComponentDataItem diComp = new CPatientItemComponentDataItem();
                                diComp.PatientID      = strPatientID;
                                diComp.ItemID         = lCompItemID;
                                diComp.ComponentID    = lComponentID;
                                diComp.ComponentValue = strComponentValue;
                                diComp.PatItemID      = lPatItemID;

                                PatItemCompList.Add(diComp);
                            }
                        }

                        //we now have a list of item components for this item
                        //loop and get status for this item and update the overall status
                        bool bHasSelectedValue = false;
                        foreach (CPatientItemComponentDataItem diPatItemComp in PatItemCompList)
                        {
                            //get the state id for this component
                            CICStateDataItem   sdi = null;
                            CItemComponentData icd = new CItemComponentData(this);
                            icd.GetICStateDI(lItemID, diPatItemComp.ComponentID, out sdi);

                            //switch on the type and get the value
                            switch ((k_ITEM_TYPE_ID)lItemTypeID)
                            {
                            case k_ITEM_TYPE_ID.Laboratory:
                            {
                                bHasSelectedValue = true;

                                //get the ranges
                                CICRangeDataItem rdi = null;
                                icd.GetICRangeDI(lItemID, diPatItemComp.ComponentID, out rdi);
                                if (String.IsNullOrEmpty(diPatItemComp.ComponentValue))
                                {
                                    //does not have a value?
                                    kOverallOSStateID = k_STATE_ID.Unknown;
                                }
                                else
                                {
                                    try
                                    {
                                        double dblValue = Convert.ToDouble(diPatItemComp.ComponentValue);

                                        //max/high check
                                        if (dblValue >= rdi.LegalMax)
                                        {
                                            if (kOverallOSStateID != k_STATE_ID.Bad)
                                            {
                                                kOverallOSStateID = k_STATE_ID.Unknown;
                                            }
                                        }
                                        else
                                        {
                                            if (dblValue >= rdi.High)
                                            {
                                                kOverallOSStateID = k_STATE_ID.Bad;
                                            }
                                            else
                                            {
                                                if (kOverallOSStateID != k_STATE_ID.Bad)
                                                {
                                                    kOverallOSStateID = k_STATE_ID.Good;
                                                }
                                            }
                                        }

                                        //min/low check
                                        if (dblValue <= rdi.LegalMin)
                                        {
                                            if (kOverallOSStateID != k_STATE_ID.Bad)
                                            {
                                                kOverallOSStateID = k_STATE_ID.Unknown;
                                            }
                                        }
                                        else
                                        {
                                            if (dblValue <= rdi.Low)
                                            {
                                                kOverallOSStateID = k_STATE_ID.Bad;
                                            }
                                            else
                                            {
                                                if (kOverallOSStateID != k_STATE_ID.Bad)
                                                {
                                                    kOverallOSStateID = k_STATE_ID.Good;
                                                }
                                            }
                                        }
                                    }
                                    catch (Exception e)
                                    {
                                        if (kOverallOSStateID != k_STATE_ID.Bad)
                                        {
                                            kOverallOSStateID = k_STATE_ID.Unknown;
                                        }
                                    }
                                }

                                break;
                            }

                            case k_ITEM_TYPE_ID.NoteTitle:
                            {
                                //note titles are excluded from quick entry
                                //so if we have one our os state is unknown
                                bHasSelectedValue = true;
                                kOverallOSStateID = k_STATE_ID.Unknown;
                                break;
                            }

                            case k_ITEM_TYPE_ID.QuestionFreeText:
                            {
                                bHasSelectedValue = true;
                                if (diPatItemComp.ComponentValue.Length < 1)
                                {
                                    //if they did not enter a value
                                    //then the overall state is bad!
                                    kOverallOSStateID = k_STATE_ID.Bad;
                                }
                                break;
                            }

                            case k_ITEM_TYPE_ID.QuestionSelection:
                                if (!String.IsNullOrEmpty(diPatItemComp.ComponentValue))
                                {
                                    //only interested in the one they selected
                                    if ((k_TRUE_FALSE_ID)Convert.ToInt64(diPatItemComp.ComponentValue) != k_TRUE_FALSE_ID.False)
                                    {
                                        bHasSelectedValue = true;
                                        if (kOverallOSStateID != k_STATE_ID.Bad)
                                        {
                                            if ((k_STATE_ID)sdi.StateID == k_STATE_ID.Bad)
                                            {
                                                kOverallOSStateID = k_STATE_ID.Bad;
                                            }
                                            else
                                            {
                                                if ((k_STATE_ID)sdi.StateID == k_STATE_ID.Good)
                                                {
                                                    if (kOverallOSStateID != k_STATE_ID.Unknown)
                                                    {
                                                        kOverallOSStateID = k_STATE_ID.Good;
                                                    }
                                                }
                                                else
                                                {
                                                    kOverallOSStateID = k_STATE_ID.Unknown;
                                                }
                                            }
                                        }
                                    }
                                }
                                break;
                            }
                        }//for each

                        //if there is nothing selected then the
                        //overall TS state is bad and the OS state is unknown
                        if (!bHasSelectedValue)
                        {
                            kOverallOSStateID = k_STATE_ID.Unknown;
                            kOverallTSStateID = k_STATE_ID.Bad;
                        }
                    }
                }
            }
        }

        //
        //now update the collection item states.
        //

        //get the ts,os and ds possible values
        CChecklistItemData dCL  = new CChecklistItemData(this);
        DataSet            dsTS = null;

        dCL.GetTemporalStateDS(lChecklistID, lCollectionItemID, out dsTS);
        long lGoodTSID    = dCL.GetTSDefaultStateID(dsTS, k_STATE_ID.Good);
        long lBadTSID     = dCL.GetTSDefaultStateID(dsTS, k_STATE_ID.Bad);
        long lUnknownTSID = dCL.GetTSDefaultStateID(dsTS, k_STATE_ID.Unknown);

        DataSet dsOS = null;

        dCL.GetOutcomeStateDS(lChecklistID, lCollectionItemID, out dsOS);
        long lGoodOSID    = dCL.GetOSDefaultStateID(dsOS, k_STATE_ID.Good);
        long lBadOSID     = dCL.GetOSDefaultStateID(dsOS, k_STATE_ID.Bad);
        long lUnknownOSID = dCL.GetOSDefaultStateID(dsOS, k_STATE_ID.Unknown);

        DataSet dsDS = null;

        dCL.GetDecisionStateDS(lChecklistID, lCollectionItemID, out dsDS);
        long lGoodDSID    = dCL.GetDSDefaultStateID(dsDS, k_STATE_ID.Good);
        long lBadDSID     = dCL.GetDSDefaultStateID(dsDS, k_STATE_ID.Bad);
        long lUnknownDSID = dCL.GetDSDefaultStateID(dsDS, k_STATE_ID.Unknown);

        //update the TS state on the data item
        if (kOverallTSStateID == k_STATE_ID.Bad)
        {
            pdi.TSID = lBadTSID;
        }
        else if (kOverallTSStateID == k_STATE_ID.Good)
        {
            pdi.TSID = lGoodTSID;
        }
        else
        {
            pdi.TSID = lUnknownTSID;
        }

        //update the OS state on the data item
        if (kOverallOSStateID == k_STATE_ID.Bad)
        {
            pdi.OSID = lBadOSID;
        }
        else if (kOverallOSStateID == k_STATE_ID.Good)
        {
            pdi.OSID = lGoodOSID;
        }
        else
        {
            pdi.OSID = lUnknownOSID;
        }

        //update the ds state on the item data
        if (kOverallTSStateID == k_STATE_ID.Good &&
            kOverallOSStateID == k_STATE_ID.Good)
        {
            pdi.DSID = lGoodDSID;
        }
        else
        {
            pdi.DSID = lBadDSID;
        }

        //update the checklist item state
        status = PatChecklistItem.UpdatePatChecklistItem(pdi);

        return(status);
    }