/// <summary>
/// US:838
/// override
/// sets focus
/// </summary>
/// <param name="lEditMode"></param>
/// <returns></returns>
public override CStatus LoadControl(k_EDIT_MODE lEditMode)
{
//get the data
DataSet ds = null;
CPatChecklistData cld = new CPatChecklistData(BaseMstr.BaseData);
CStatus status = cld.GetPatCLByCLIDCLSTATEDS(
ChecklistID,
(long)k_CHECKLIST_STATE_ID.Open,
PatientIDs,
out ds);
if (!status.Status)
{
return(status);
}
PatientDataTable = ds.Tables[0];
gvExistingCL.DataSource = PatientDataTable;
gvExistingCL.DataBind();
if (PatientDataTable.Rows.Count > 0)
{
ShowMPE();
}
else
{
StoreAndContinue();
}
return(new CStatus());
}
/// <summary>
/// loop and update the users checklists
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnSave_Click(object sender, EventArgs e)
{
bool bUpdated = false;
foreach (GridViewRow gvr in gvOutOfDateCL.Rows)
{
CheckBox cb = gvr.FindControl("chkSelect") as CheckBox;
if (cb != null)
{
if (cb.Checked)
{
CStatus status = new CStatus();
CPatChecklistData dta = new CPatChecklistData(BaseMstr.BaseData);
dta.UpdatePatCLVersion(Convert.ToInt32(gvOutOfDateCL.DataKeys[gvr.RowIndex].Value));
bUpdated = true;
}
}
}
if (bUpdated)
{
if (_UpdateVersion != null)
{
CAppUserControlArgs args = new CAppUserControlArgs(
k_EVENT.UPDATE,
k_STATUS_CODE.Success,
string.Empty,
"1");
_UpdateVersion(this, args);
}
}
}
/// <summary>
/// method
/// US:902
/// runs the logic for all the checklists for the patient specified
/// </summary>
/// <param name="strPatientID"></param>
/// <param name="lItemID"></param>
/// <returns></returns>
public CStatus RunLogic(string strPatientID)
{
CPatChecklistData pcl = new CPatChecklistData(this);
DataSet dsPatientChecklists = null;
CStatus status = pcl.GetPatChecklistDS(strPatientID, out dsPatientChecklists);
if (!status.Status)
{
return(status);
}
CPatChecklistItemData pcli = new CPatChecklistItemData(this);
foreach (DataRow drChecklist in dsPatientChecklists.Tables[0].Rows)
{
try
{
status = RunLogic(Convert.ToInt64(drChecklist["PAT_CL_ID"]));
}
catch
{
return(new CStatus(false, k_STATUS_CODE.Failed, LogicModuleMessages.ERROR_RUN_LOGIC));
}
if (!status.Status)
{
return(status);
}
}
return(new CStatus());
}
/// <summary>
/// override
/// US:878
/// saves the checklist
/// </summary>
/// <param name="lStatusCode"></param>
/// <param name="strStatusComment"></param>
/// <returns></returns>
public override CStatus SaveControl()
{
CPatChecklistData pcld = new CPatChecklistData(BaseMstr.BaseData);
CPatChecklistDataItem di = null;
CStatus status = pcld.GetPatChecklistDI(Convert.ToInt64(ddlPatChecklist.SelectedValue), out di);
if (!status.Status)
{
return(status);
}
di.ChecklistStateID = (k_CHECKLIST_STATE_ID)Convert.ToInt64(ddlChecklistState.SelectedValue);
di.ProcedureDate = CDataUtils.GetDate(
tbProcedureDate.Text,
ucProcedureTime.HH,
ucProcedureTime.MM,
ucProcedureTime.SS);
status = pcld.UpdatePatChecklist(di);
if (!status.Status)
{
return(status);
}
return(new CStatus());
}
protected void OnContinueExisting(object sender, CAppUserControlArgs e)
{
CPatChecklistDataItem di = new CPatChecklistDataItem();
di.ProcedureDate = CDataUtils.GetNullDate();
di.AssignmentDate = DateTime.Now;
di.ChecklistID = ucExistingChecklist.ChecklistID;
di.ChecklistStateID = k_CHECKLIST_STATE_ID.Open;
di.PatientID = PatientID;
di.StateID = k_STATE_ID.Unknown;
long lPatCLID = 0;
CPatChecklistData pcld = new CPatChecklistData(BaseMstr.BaseData);
CStatus status = pcld.InsertPatChecklist(di, out lPatCLID);
if (!status.Status)
{
ShowStatusInfo(status);
return;
}
if (BaseMstr.MDWSTransfer)
{
//talk to the communicator to update the
//patient checklist from mdws
CCommunicator com = new CCommunicator();
status = com.RefreshPatientCheckList(
BaseMstr.DBConn,
BaseMstr.BaseData,
PatientID,
lPatCLID);
if (!status.Status)
{
ShowStatusInfo(status);
return;
}
}
CPatientChecklist pcl = new CPatientChecklist();
status = pcl.LoadPatientChecklists(BaseMstr, PatientID, ddlPatChecklist);
if (!status.Status)
{
ShowStatusInfo(status);
return;
}
ddlPatChecklist.SelectedValue = lPatCLID.ToString();
status = LoadChecklist();
if (!status.Status)
{
ShowStatusInfo(status);
return;
}
//set the UI permissions based on the user logged in
SetPermissions(btnTIU.Enabled);
}
/// <summary>
/// US:864 US:876 loads a dropdown list with patient checklists, will screen out
/// check lists that the user does not have view permissions for.
/// </summary>
/// <param name="BaseMastr"></param>
/// <param name="strPatientID"></param>
/// <param name="ddl"></param>
/// <returns></returns>
public CStatus LoadPatientChecklists(CBaseMaster BaseMstr, string strPatientID, DropDownList ddl)
{
CPatientChecklistLogic pcl = new CPatientChecklistLogic(BaseMstr.BaseData);
CStatus status = pcl.RunLogic(strPatientID);
if (!status.Status)
{
return(status);
}
CPatChecklistData pc = new CPatChecklistData(BaseMstr.BaseData);
DataSet ds = null;
status = pc.GetPatChecklistDS(strPatientID, out ds);
if (!status.Status)
{
return(status);
}
//remove records from the ds that the user is not allowed to view
foreach (DataTable table in ds.Tables)
{
foreach (DataRow dr in table.Rows)
{
long lChecklistID = CDataUtils.GetDSLongValue(dr, "CHECKLIST_ID");
CChecklistPermissionsDataItem pdi = null;
CChecklistData clData = new CChecklistData(BaseMstr.BaseData);
clData.GetCheckListPermissionsDI(lChecklistID, out pdi);
//is the user allowed to view this checklist
if (!pdi.HasPermission(BaseMstr.AppUser, k_CHECKLIST_PERMISSION.Viewable))
{
dr.Delete();
}
}
}
ds.AcceptChanges();
//render the dataset
status = CDropDownList.RenderDataSet(
ds,
ddl,
"CHECKLIST_LABEL",
"PAT_CL_ID");
if (!status.Status)
{
return(status);
}
return(new CStatus());
}
/// <summary>
/// override
/// sets focus
/// </summary>
/// <param name="lEditMode"></param>
/// <param name="lStatusCode"></param>
/// <param name="strStatusComment"></param>
/// <returns></returns>
public override CStatus LoadControl(k_EDIT_MODE lEditMode)
{
CStatus status = new CStatus();
CPatChecklistData dta = new CPatChecklistData(BaseMstr.BaseData);
DataSet dsCL = null;
dta.GetOutOfDatePatCLDS(PatientID, ChecklistID, out dsCL);
gvOutOfDateCL.DataSource = dsCL.Tables[0];
gvOutOfDateCL.DataBind();
return(status);
}
/// <summary>
/// override
/// sets focus
/// </summary>
/// <param name="lEditMode"></param>
/// <param name="lStatusCode"></param>
/// <param name="strStatusComment"></param>
/// <returns></returns>
public override CStatus LoadControl(k_EDIT_MODE lEditMode)
{
CStatus status = new CStatus();
//get all the patients for the mulitpatient
string strCLIDs = String.Empty;
string strPatIDs = String.Empty;
CPatientData pat = new CPatientData(BaseMstr.BaseData);
DataSet dsMultiPatientSearch = null;
status = pat.GetMultiPatientSearchDS(EventStartDate,
EventEndDate,
ChecklistID,
ChecklistStatusID,
ChecklistServiceID,
out dsMultiPatientSearch);
//get patient ids
CDataUtils.GetDSDelimitedData(dsMultiPatientSearch,
"PATIENT_ID",
",",
out strPatIDs);
strPatIDs = "," + strPatIDs;
//get pat cl ids
CDataUtils.GetDSDelimitedData(dsMultiPatientSearch,
"CHECKLIST_ID",
",",
out strCLIDs);
strCLIDs = "," + strCLIDs;
CPatChecklistData dta = new CPatChecklistData(BaseMstr.BaseData);
DataSet dsCL = null;
status = dta.GetOutOfDatePatCLDS(EventStartDate,
EventEndDate,
ChecklistID,
ChecklistStatusID,
strPatIDs,
strCLIDs,
out dsCL);
//if (!CDataUtils.IsEmpty(dsCL))
//{
gvOutOfDateCL.DataSource = dsCL.Tables[0];
gvOutOfDateCL.DataBind();
//}
return(status);
}
/// <summary>
/// method
/// US:911
/// cancels the checklist specified by the patient checklist id
/// </summary>
/// <param name="lPatCLID"></param>
/// <returns></returns>
private CStatus CancelChecklist(long lPatCLID)
{
CPatChecklistData PatChecklist = new CPatChecklistData(BaseData);
CPatChecklistDataItem di = null;
CStatus status = PatChecklist.GetPatChecklistDI(lPatCLID, out di);
if (!status.Status)
{
return(status);
}
di.ChecklistStateID = k_CHECKLIST_STATE_ID.Cancelled;
return(PatChecklist.UpdatePatChecklist(di));
}
/// <summary>
/// event
/// displays the edit checklist item component dialog
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void OnClickEditItem(object sender, EventArgs e)
{
CPatChecklistData pcld = new CPatChecklistData(BaseMstr.BaseData);
CPatChecklistDataItem di = null;
CStatus status = pcld.GetPatChecklistDI(PatientChecklistID, out di);
if (!status.Status)
{
ShowStatusInfo(k_STATUS_CODE.Failed, Resources.ErrorMessages.ERROR_SP_CURCHECKLIST);
return;
}
if (di.ChecklistStateID == k_CHECKLIST_STATE_ID.Cancelled ||
di.ChecklistStateID == k_CHECKLIST_STATE_ID.Closed)
{
ShowStatusInfo(k_STATUS_CODE.Failed, Resources.ErrorMessages.ERROR_SP_CHECKLISTSTATE);
return;
}
Button btnSender = (Button)sender;
if (btnSender == null)
{
ShowStatusInfo(k_STATUS_CODE.Failed, Resources.ErrorMessages.ERROR_SP_ITEM);
return;
}
ucItemEditor.PatientID = PatientID;
ucItemEditor.ChecklistID = ChecklistID;
ucItemEditor.ItemID = Convert.ToInt64(btnSender.Attributes["ITEM_ID"]);
ucItemEditor.ChecklistItemID = Convert.ToInt64(btnSender.Attributes["ITEM_ID"]);
ucItemEditor.PatientChecklistID = PatientChecklistID;
k_EDIT_MODE lEditMode = k_EDIT_MODE.INITIALIZE;
status = ucItemEditor.LoadControl(lEditMode);
if (!status.Status)
{
ShowStatusInfo(status);
return;
}
ucItemEditor.ShowMPE();
}
/// <summary>
/// override
/// validates the checklist's fields
/// </summary>
/// <param name="lStatusCode"></param>
/// <param name="plistStatus"></param>
/// <returns></returns>
public override CStatus ValidateUserInput(out CParameterList plistStatus)
{
plistStatus = new CParameterList();
CPatChecklistData pcld = new CPatChecklistData(BaseMstr.BaseData);
CPatChecklistDataItem di = null;
CStatus status = pcld.GetPatChecklistDI(Convert.ToInt64(ddlPatChecklist.SelectedValue), out di);
if (!status.Status)
{
plistStatus.AddInputParameter("ERROR_SP_CURCHECKLIST", Resources.ErrorMessages.ERROR_SP_CURCHECKLIST);
return(status);
}
if (ChecklistStateID != di.ChecklistStateID &&
(di.ChecklistStateID == k_CHECKLIST_STATE_ID.Cancelled || di.ChecklistStateID == k_CHECKLIST_STATE_ID.Closed))
{
plistStatus.AddInputParameter("ERROR_SP_CHECKLISTSTATE", Resources.ErrorMessages.ERROR_SP_CHECKLISTSTATE);
status.Status = false;
status.StatusCode = k_STATUS_CODE.Failed;
return(status);
}
DateTime dtProceduteDate = CDataUtils.GetDate(
tbProcedureDate.Text,
ucProcedureTime.HH,
ucProcedureTime.MM,
ucProcedureTime.SS);
if (dtProceduteDate != CDataUtils.GetNullDate() && dtProceduteDate < DateTime.Now)
{
plistStatus.AddInputParameter("ERROR_PROCEDURE_DATE", Resources.ErrorMessages.ERROR_PROCEDURE_DATE);
}
if (plistStatus.Count > 0)
{
status.Status = false;
status.StatusCode = k_STATUS_CODE.Failed;
}
return(status);
}
public override CStatus LoadControl(k_EDIT_MODE lEditMode)
{
//get the data
CPatChecklistData cld = new CPatChecklistData(BaseMstr.BaseData);
bool bHasPatCL = false;
CStatus status = cld.HasPatientChecklist(
ChecklistID,
(long)k_CHECKLIST_STATE_ID.Open,
PatientID,
out bHasPatCL);
if (!status.Status)
{
return(status);
}
if (bHasPatCL)
{
ShowMPE();
}
else
{
if (_Continue != null)
{
CAppUserControlArgs args = new CAppUserControlArgs(
k_EVENT.SELECT,
k_STATUS_CODE.Success,
string.Empty,
"1");
_Continue(this, args);
}
}
return(new CStatus());
}
/// <summary>
/// loads the gridview after we are done updating the checklists
/// </summary>
protected CStatus LoadGridView()
{
//done processing the logic so now load the gridview
//set the date from and date to
DateTime dtFrom = CDataUtils.GetNullDate();
DateTime dtTo = CDataUtils.GetNullDate();
if (chkFilterByEvent.Checked)
{
dtFrom = CDataUtils.GetDate(txtFromDate.Text);
dtTo = CDataUtils.GetDate(txtToDate.Text);
}
MPEventStartDate = dtFrom;
MPEventEndDate = dtTo;
//checklist id
long lChecklistID = -1;
if (chkChecklist.Checked)
{
lChecklistID = ChecklistID;
}
MPChecklistID = lChecklistID;
//set the checklist Status
long lChecklistStatusID = -1;
if (chkChecklistStatus.Checked &&
ddlChecklistStatus.SelectedItem != null &&
ddlChecklistStatus.SelectedValue != "-1")
{
lChecklistStatusID = CDataUtils.ToLong(ddlChecklistStatus.SelectedValue);
}
MPChecklistStatusID = lChecklistStatusID;
long lChecklistServiceID = -1;
if (chkFilterByCLService.Checked &&
ddlFilterByService.SelectedItem != null &&
ddlFilterByService.SelectedValue != "-1")
{
lChecklistServiceID = CDataUtils.ToLong(ddlFilterByService.SelectedValue);
}
MPChecklistServiceID = lChecklistServiceID;
CStatus status = GetPatients(dtFrom,
dtTo,
lChecklistID,
lChecklistStatusID,
lChecklistServiceID);
if (!status.Status)
{
return(status);
}
AddColumns();
gvMultiPatientView.EmptyDataText = "No result(s) found.";
gvMultiPatientView.DataSource = MultiPatients;
gvMultiPatientView.DataBind();
//now that the grid is loaded check for new versions...
//get all the patients for the mulitpatient
string strCLIDs = string.Empty;
string strPatIDs = string.Empty;
CPatientData pat = new CPatientData(Master.BaseData);
DataSet dsMultiPatientSearch = null;
status = pat.GetMultiPatientSearchDS(
MPEventStartDate,
MPEventEndDate,
MPChecklistID,
MPChecklistStatusID,
MPChecklistServiceID,
out dsMultiPatientSearch);
if (!status.Status)
{
return(status);
}
//patient ids
CDataUtils.GetDSDelimitedData(
dsMultiPatientSearch,
"PATIENT_ID",
",",
out strPatIDs);
strPatIDs = "," + strPatIDs;
//pat cl ids
CDataUtils.GetDSDelimitedData(
dsMultiPatientSearch,
"CHECKLIST_ID",
",",
out strCLIDs);
strCLIDs = "," + strCLIDs;
CPatChecklistData dta = new CPatChecklistData(Master.BaseData);
DataSet dsCL = null;
status = dta.GetOutOfDatePatCLDS(
MPEventStartDate,
MPEventEndDate,
MPChecklistID,
MPChecklistStatusID,
strPatIDs,
strCLIDs,
out dsCL);
if (!status.Status)
{
return(status);
}
btnUpdateCLVersion.Enabled = (!CDataUtils.IsEmpty(dsCL)) ? true : false;
//EnableVersionUpdate = (!CDataUtils.IsEmpty(dsCL)) ? true : false;
upLookup.Update();
return(new CStatus());
}
/// <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());
}
/// <summary>
/// do the actual work of assigning the checklist
/// </summary>
/// <param name="state"></param>
public void DoWork(Object state)
{
//thread hashcount work
lock (HashCount)
{
if (!HashCount.ContainsKey(Thread.CurrentThread.GetHashCode()))
{
HashCount.Add(Thread.CurrentThread.GetHashCode(), 0);
}
HashCount[Thread.CurrentThread.GetHashCode()] = ((int)HashCount[Thread.CurrentThread.GetHashCode()]) + 1;
}
//do the real work here
//////////////////////////////////////////////////////////////
//create a new connection for the thread
CDataDBConn conn = new CDataDBConn();
conn.Connect();
CData data = new CData(
conn,
this.ClientIP,
this.UserID,
this.SessionID,
this.WebSession,
this.MDWSTransfer);
CPatChecklistData pcl = new CPatChecklistData(data);
string strPatientID = PatientID;
CPatChecklistDataItem di = new CPatChecklistDataItem();
di.ProcedureDate = CDataUtils.GetNullDate();
di.AssignmentDate = DateTime.Now;
di.ChecklistID = ChecklistID;
di.ChecklistStateID = k_CHECKLIST_STATE_ID.Open;
di.PatientID = strPatientID;
di.StateID = k_STATE_ID.Unknown;
long lPatCLID = 0;
Status = pcl.InsertPatChecklist(di, out lPatCLID);
if (Status.Status)
{
if (MDWSTransfer)
{
//talk to the communicator to update the
//patient checklist from mdws
CCommunicator com = new CCommunicator();
Status = com.RefreshPatientCheckList(
conn,
data,
strPatientID,
lPatCLID);
}
if (Status.Status)
{
CPatientChecklistLogic pcll = new CPatientChecklistLogic(data);
Status = pcll.RunLogic(lPatCLID);
}
}
//cleanup the database connection
conn.Close();
//signals we are done.
Interlocked.Increment(ref ThreadCount);
if (ThreadCount == ThreadMax)
{
if (eventX != null)
{
eventX.Set();
ThreadCount = 0;
ThreadMax = 0;
}
}
}
/// <summary>
/// US:1956 US:885 load the control with data
/// </summary>
/// <param name="lEditMode"></param>
/// <returns></returns>
public override CStatus LoadControl(k_EDIT_MODE lEditMode)
{
CStatus status = CClinic.LoadClinicDLL(BaseMstr.BaseData, ddlClinics);
if (!status.Status)
{
return(status);
}
//load the tiu note
string strTIU = String.Empty;
string strNoteTitle = String.Empty;
CPatChecklistData clData = new CPatChecklistData(BaseMstr.BaseData);
status = clData.GetTIUText(
PatientID,
PatChecklistID,
out strNoteTitle,
out strTIU);
if (!status.Status)
{
return(status);
}
//keep the note title as a property
NoteTitle = strNoteTitle;
//select the note title default clinic from the checklist
CPatChecklistDataItem pdi = new CPatChecklistDataItem();
status = clData.GetPatChecklistDI(PatChecklistID, out pdi);
if (!status.Status)
{
return(status);
}
CChecklistDataItem cli = new CChecklistDataItem();
CChecklistData cld = new CChecklistData(BaseMstr.BaseData);
status = cld.GetCheckListDI(pdi.ChecklistID, out cli);
if (!status.Status)
{
return(status);
}
if (cli.NoteTitleClinicID > 0)
{
ddlClinics.SelectedValue = cli.NoteTitleClinicID.ToString();
}
//show the note title at the top of the popup
lblNoteTitle.Text = strNoteTitle;
//the note title tag is the title of the note, but we need the ien
//to write the note...
long lNoteTitleIEN = 0;
CNoteTitleData nd = new CNoteTitleData(BaseMstr.BaseData);
status = nd.GetNoteTitleIEN(strNoteTitle, out lNoteTitleIEN);
if (!status.Status)
{
return(status);
}
NoteTitleIEN = Convert.ToString(lNoteTitleIEN);
//set the text for the note
txtTIU.Text = strTIU;
return(new CStatus());
}
/// <summary>
/// US:1880 method
/// loads the selected checklist
/// </summary>
/// <returns></returns>
protected CStatus LoadChecklist()
{
PatCLID = Convert.ToInt64(ddlPatChecklist.SelectedValue);
if (PatCLID < 1)
{
return(new CStatus(false, k_STATUS_CODE.Failed, "TODO"));
}
CPatientChecklist pcl = new CPatientChecklist();
CStatus status = pcl.LoadPatientChecklists(BaseMstr, PatientID, ddlPatChecklist);
if (!status.Status)
{
return(status);
}
ddlPatChecklist.SelectedValue = PatCLID.ToString();
CPatChecklistData pcld = new CPatChecklistData(BaseMstr.BaseData);
CPatChecklistDataItem di = null;
status = pcld.GetPatChecklistDI(PatCLID, out di);
if (!status.Status)
{
return(status);
}
ddlChecklistState.SelectedValue = Convert.ToInt64(di.ChecklistStateID).ToString();
ChecklistID = di.ChecklistID;
ChecklistStateID = di.ChecklistStateID;
EnableBasedOnChecklistState();
//enable/disable the button based on the checklist selected
CPatChecklistData dta = new CPatChecklistData(BaseMstr.BaseData);
DataSet dsCL = null;
dta.GetOutOfDatePatCLDS(PatientID, ChecklistID, out dsCL);
if (!CDataUtils.IsEmpty(dsCL))
{
btnUpdateCLVersion.Enabled = true;
lblVersion.Text = "New Version Available!";
}
else
{
btnUpdateCLVersion.Enabled = false;
lblVersion.Text = "Version is Current.";
}
if (!CDataUtils.IsDateNull(di.ProcedureDate))
{
tbProcedureDate.Text = CDataUtils.GetDateAsString(di.ProcedureDate);
calProcedureDate.SelectedDate = di.ProcedureDate;
ucProcedureTime.SetTime(di.ProcedureDate);
}
else
{
tbProcedureDate.Text = string.Empty;
calProcedureDate.SelectedDate = null;
ucProcedureTime.HH = 0;
ucProcedureTime.MM = 0;
ucProcedureTime.SS = 0;
}
//checklist data - check for notetitle and disable tiu if we dont have one
CChecklistData clData = new CChecklistData(BaseMstr.BaseData);
CChecklistDataItem diChecklist = null;
status = clData.GetCheckListDI(di.ChecklistID, out diChecklist);
if (!status.Status)
{
return(status);
}
btnTIU.Enabled = (diChecklist.NoteTitleTag != "-1") ? true: false;
CPatientData p = new CPatientData(BaseMstr.BaseData);
string strBlurb = string.Empty;
status = p.GetPatientBlurb(PatientID, out strBlurb);
if (!status.Status)
{
return(status);
}
sPatientBlurb.InnerText = strBlurb + " for " + diChecklist.ChecklistLabel;
ucPatCLItems.PatientChecklistID = di.PatCLID;
ucPatCLItems.PatientID = di.PatientID;
ucPatCLItems.ChecklistID = di.ChecklistID;
status = LoadPatientChecklistItems();
if (!status.Status)
{
return(status);
}
EnableTIU();
return(new CStatus());
}
