public void CopyField(ICaisisInputControl srcCIC, ICaisisInputControl destCIC)
{
if (this.getterDelegate != null && this.setterDelegate != null)
{
SetFieldValue(destCIC, GetFieldValue(srcCIC));
}
}
/// <summary>
///
/// </summary>
/// <param name="cic"></param>
/// <param name="valToSet"></param>
public void SetFieldValue(ICaisisInputControl iCICInstance, object valToSet)
{
string val = valToSet != null?valToSet.ToString() : null;
if (setterDelegate != null && val != null)
{
if (setterDelegate is MetaStringSetter)
{
(setterDelegate as MetaStringSetter)(iCICInstance, val);
}
// parseable values need to be non-empty
else if (!string.IsNullOrEmpty(val))
{
if (setterDelegate is MetaBoolSetter)
{
(setterDelegate as MetaBoolSetter)(iCICInstance, bool.Parse(val));
}
else if (setterDelegate is MetaIntSetter)
{
(setterDelegate as MetaIntSetter)(iCICInstance, int.Parse(val));
}
else if (setterDelegate is MetaDoubleSetter)
{
(setterDelegate as MetaDoubleSetter)(iCICInstance, double.Parse(val));
}
}
}
}
protected override void SetInputControlValue(ICaisisInputControl attributeValueField, string attributeValue, DataRow data)
{
if (data != null)
{
string tableName = data[MetadataTable.TableName_Field].ToString();
string attributeName = data[MetadataTableAttribute.TableAttributeName].ToString();
// handle special cases
switch (attributeName)
{
case ("DisplayWithChild"):
SetDisplayWithChild(attributeValueField, tableName, attributeValue);
break;
case ("GridView"):
SetGridView(attributeValueField, tableName, attributeValue);
break;
default:
base.SetInputControlValue(attributeValueField, attributeValue, data);
break;
}
}
else
{
base.SetInputControlValue(attributeValueField, attributeValue, data);
}
}
private void AddControl(BOL.BusinessObject b, string fieldname, IDictionary <string, string> extensions)
{
ICaisisInputControl control = controller.BuildControl(b, fieldname);
// TODO: handle control.Required via js list
if (control.Required)
{
controlsToValidate.Add(control as Control);
}
// kill the labels and help
control.ShowHelpBubble = false;
// control.ShowLabel = false;
// use extensions to find page#, section#, row#, column#
int page = int.Parse(extensions["Page"]);
int section = int.Parse(extensions["Section"]);
int row = int.Parse(extensions["Row"]);
int column = int.Parse(extensions["Column"]);
Panel panel = new Panel();
panel.CssClass = "dataEntrControlCell";
panel.Controls.Add(control as Control);
AddControl(panel, page, section, row, column);
}
/// <summary>
/// Add a new Lesion (DxImageFindings) record
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void AddLesionClick(object sender, EventArgs e)
{
// Get field values for add adding new lesion
Control petFields = NewDxImageFindingPanel.FindControl("DX_PET_Fields");
Control ctMRIFields = NewDxImageFindingPanel.FindControl("DX_CTMRI_Fields");
Control shareFields = NewDxImageFindingPanel.FindControl("DX_SHARED_Fields");
Control mainFields = ImageType == "PET" ? petFields : ctMRIFields;
ICaisisInputControl diagnosticField = FindInputControl(mainFields, ImageFinding.DiagnosticId);
string diagnosticId = diagnosticField.Value;
if (!string.IsNullOrEmpty(diagnosticId))
{
int diagId = int.Parse(diagnosticId);
ImageFinding newFinding = new ImageFinding();
newFinding[ImageFinding.DiagnosticId] = diagId;
CICHelper.SetBOValues(mainFields.Controls, newFinding, diagId);
// special fields
string imgFindTarget = FindInputControl(mainFields, ImageFinding.ImgFindTarget).Value;
int imgFindGroupNum = GetNextGroupNum();
newFinding[ImageFinding.ImgFindGroupNum] = imgFindGroupNum;
newFinding[ImageFinding.ImgFindTarget] = imgFindTarget;
newFinding.Save();
}
// Save Matrix
MainSaveBtnClick(sender, e);
}
protected void SetInputControls(object sender, RepeaterItemEventArgs e)
{
if (e.Item.ItemIndex > -1)
{
Control container = e.Item.FindControl("QuestionResponseControl");
Label label = e.Item.FindControl("QuestionText") as Label;
string controlType = DataBinder.Eval(e.Item.DataItem, "ResponseControlType").ToString();
int questionId = (int)DataBinder.Eval(e.Item.DataItem, "MetadataSurveyQuestionId");
if (!string.IsNullOrEmpty(controlType))
{
ICaisisInputControl iInputControl = CICHelper.InvokeInputControl(controlType);
iInputControl.ShowLabel = false;
Control input = iInputControl as Control;
container.Controls.Add(input);
label.AssociatedControlID = input.ID;
if (input is ListControl)
{
DataView listData = BOL.BusinessObject.GetByParentAsDataView <BOL.MetadataQuestionResponse>(questionId);
ListControl iListInput = input as ListControl;
iListInput.DataTextField = "ResponseText";
iListInput.DataValueField = "ResponseValue";
iListInput.DataSource = listData;
iListInput.DataBind();
}
}
}
}
protected void SetFieldValues(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
// set button states
string priKey = DataBinder.Eval(e.Row.DataItem, MedicalTherapy.MedicalTherapyId) + "";
bool isLocked = (DataBinder.Eval(e.Row.DataItem, BusinessObject.LockedBy) + "") != "";
var exists = priKey != "";
Control lockImg = e.Row.FindControl("LockImage");
Control clearImg = e.Row.FindControl("ClearImage");
lockImg.Visible = isLocked;
clearImg.Visible = !exists;
// lock inputs
if (isLocked)
{
var inputs = CICHelper.GetCaisisInputControls(e.Row);
inputs.ForEach(i => i.Enabled = false);
}
// special case: set TxType
ICaisisInputControl txTypeInput = e.Row.FindControl("MedTxType") as ICaisisInputControl;
if (string.IsNullOrEmpty(priKey))
{
if (!string.IsNullOrEmpty(TxType))
{
txTypeInput.Value = TxType;
}
}
else
{
txTypeInput.Value = DataBinder.Eval(e.Row.DataItem, MedicalTherapy.MedTxType).ToString();
}
}
}
protected void MarkTableFieldsDirty(ICaisisInputControl sender, EventArgs e)
{
if (!dirtyTables.Contains(sender.Table))
{
dirtyTables.Add(sender.Table);
}
}
public static void BindControl(ICaisisInputControl control, IBusinessObject b, string fieldname)
{
// special case: data bound controls (select, radio list, check box list, etc... get values set late bound
if (control is System.Web.UI.WebControls.ListControl)
{
var setter = new EventHandler((o, e) =>
{
control.Value = b[fieldname].ToString();
if (b.IsLocked)
{
control.Enabled = false;
}
});
var iListControl = control as System.Web.UI.WebControls.ListControl;
iListControl.DataBound += setter;
}
else
{
var setter = new CaisisEventHandler((o, e) =>
{
control.Value = b[fieldname].ToString();
if (b.IsLocked)
{
control.Enabled = false;
}
});
control.PreRender += setter;
}
// track control change during POSTs
control.ValueChanged += new CaisisEventHandler((o, e) => b[fieldname] = control.Value);
// control.ValueChanged += new CaisisEventHandler((o, e) => DebugHack(o, o.Value));
}
/// <summary>
/// Raises the build control events, signaling an input control has been built
/// </summary>
/// <param name="iCIC"></param>
protected void OnBuildControl(ICaisisInputControl iCIC)
{
if (BuildControl != null)
{
BuildControl(iCIC, EMPTY_EVENT_ARGS);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void UpdateEformStatuses(object sender, EventArgs e)
{
// manually update eform statuses
foreach (int dirtyRowIndex in dirtyRows)
{
Control row = EFormActivityRptr.Items[dirtyRowIndex];
// get status text
ICaisisInputControl eformIdField = row.FindControl("EFormId") as ICaisisInputControl;
ICaisisInputControl statusField = row.FindControl("StatusField") as ICaisisInputControl;
ICaisisInputControl EFormApptPhysicianField = row.FindControl("EFormApptPhysicianField") as ICaisisInputControl;
ICaisisInputControl EFormApptTimeField = row.FindControl("EFormApptTimeField") as ICaisisInputControl;
// load record and update status field
int eformId = int.Parse(eformIdField.Value);
BOL.EForm biz = new EForm();
biz.Get(eformId);
biz[BOL.EForm.CurrentStatus] = statusField.Value;
biz[BOL.EForm.EformApptPhysician] = EFormApptPhysicianField.Value;
biz[BOL.EForm.EformApptTime] = EFormApptTimeField.Value;
biz.Save();
}
// rebind list to show updated statuses
BuildEformStatusList(BOL.EForm.EFormId, SortDirection.Ascending);
}
protected void FixSelected(Control row)
{
ICaisisInputControl surveyIdField = row.FindControl("SurveyId") as ICaisisInputControl;
int surveyId = int.Parse(surveyIdField.Value);
// create a lookup for each discrete score
Dictionary <string, string> scoresToValues = new Dictionary <string, string>();
foreach (var column in SCORE_COLUMNS)
{
string columnName = column.Key;
string columnDisplayName = column.Value;
string scoreFieldId = columnName.Replace(" ", "");
var scoreField = row.FindControl(scoreFieldId) as ICaisisInputControl;
string scoreValue = scoreField.Value;
scoresToValues.Add(columnName, scoreValue);
}
// update notes field
Survey survey = new Survey();
survey.Get(surveyId);
// get current notes
string sourceSurveyNotes = survey[Survey.SurveyNotes].ToString();
// get computed notes
string computedSurveyNotes = GetComputedSurveyNotes(sourceSurveyNotes, scoresToValues);
// update notes field
survey[Survey.SurveyNotes] = computedSurveyNotes;
survey.Save();
}
private void EnableControls(ControlCollection col, bool val)
{
foreach (Control c in col)
{
if (c is ICaisisInputControl)
{
ICaisisInputControl ic = c as ICaisisInputControl;
ic.Enabled = val;
}
else if (c is ImageButton)
{
ImageButton ib = c as ImageButton;
if (val == true)
{
ib.Style.Add("cursor", "pointer");
}
else
{
ib.Style.Add("cursor", "default");
}
ib.Enabled = val;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="tableAttributeField"></param>
/// <param name="e"></param>
protected void MarkTableAttributeDirty(ICaisisInputControl tableAttributeField, EventArgs e)
{
if (!dirtyTableAttributes.Contains(tableAttributeField.Field))
{
dirtyTableAttributes.Add(tableAttributeField.Field);
}
}
/// <summary>
/// Sets the checkbox for the specified type (dataset or tab)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void SetCheckBoxes(object sender, RepeaterItemEventArgs e)
{
if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
{
// get checkbox
CaisisCheckBox keyField = e.Item.FindControl("KeyField") as CaisisCheckBox;
// get value field
ICaisisInputControl valueField = e.Item.FindControl("ValueField") as ICaisisInputControl;
// handle dataset access
if (sender == DatasetsRptr)
{
int rowDatasetId = (int)DataBinder.Eval(e.Item.DataItem, Dataset.DatasetId);
var found = from g in currentGroupDatasets
let d = (int)g[GroupDataset.DatasetId]
where d == rowDatasetId
select g;
if (found.Count() > 0)
{
keyField.Checked = true;
// set pri key
valueField.Value = found.First()[GroupDataset.GroupDatasetId].ToString();
}
}
// handle tab access
else if (sender == TabsRptr)
{
string tabName = e.Item.DataItem.ToString();
// check if tab is in access code
keyField.Checked = currentGroupAccessTabs.Contains(tabName);
}
}
}
private void FixListControlLayout(ICaisisInputControl sender, EventArgs e)
{
if (sender is CheckBoxList)
{
sender.PreRender += SetListControlLayout;
}
}
/// <summary>
/// Populates the status for the current control
/// </summary>
/// <param name="container"></param>
/// <param name="status"></param>
private void PopulateStatus(Control container, string status)
{
HiddenField StatusIdField = container.FindControl("StatusIdField") as HiddenField;
ICaisisInputControl Status_Field = container.FindControl("Status_Field") as ICaisisInputControl;
ICaisisInputControl StatusDisease = container.FindControl("StatusDisease") as ICaisisInputControl;
ImageButton deleteBtn = container.FindControl("DeleteBtn") as ImageButton;
// get pri key
int?statusId = GetStaustId(status);
// set hidden field
StatusIdField.Value = statusId + "";
// populate
if (statusId.HasValue)
{
Status biz = new Status();
biz.Get(statusId.Value);
CICHelper.SetFieldValues(container.Controls, biz);
}
// set inital values
else
{
CICHelper.ClearCaisisInputControlValues(container);
// set required values
StatusDisease.Value = STATUS_DISEASE;
Status_Field.Value = status;
}
// set delete
deleteBtn.Visible = statusId.HasValue;
}
/// <summary>
/// Builds static list of available Lookup Codes
/// </summary>
/// <param name="combo"></param>
private void BuildLookupCodeCombo(ICaisisInputControl icic)
{
if (icic is CaisisComboBox)
{
CaisisComboBox combo = icic as CaisisComboBox;
combo.BuildComboData(LookupCodesTable, LookupCode.LkpFieldName, LookupCode.LkpFieldName);
}
}
private void SetListControlLayout(ICaisisInputControl sender, EventArgs e)
{
CheckBoxList cbl = sender as CheckBoxList;
int count = cbl.Items.Count;
int columns = Math.Min(3, Math.Max(1, count / 10));
cbl.RepeatColumns = columns;
}
// TODO: use BO's static methods
public ICaisisInputControl BuildControl(Caisis.BOL.BusinessObject b, string fieldname)
{
ICaisisInputControl control = CaisisInputControlFactory.BuildControl(GetControlInstance, b, fieldname);
CustomizeControl(control, b.TableName, fieldname);
return(control);
}
/// <summary>
/// When control value changes, mark row as "dirty"
/// </summary>
/// <param name="icic"></param>
/// <param name="e"></param>
protected void MarkRowDirty(ICaisisInputControl icic, EventArgs e)
{
RepeaterItem rptrItem = (icic as Control).NamingContainer as RepeaterItem;
if (!dirtyRows.Contains(rptrItem.ItemIndex))
{
dirtyRows.Add(rptrItem.ItemIndex);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void MarkRowDirty(ICaisisInputControl sender, EventArgs e)
{
int rowIndex = ((sender as Control).NamingContainer as GridViewRow).RowIndex;
if (!dirtyVisits.Contains(rowIndex))
{
dirtyVisits.Add(rowIndex);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SetControlToolTip(ICaisisInputControl sender, EventArgs e)
{
string table = sender.Table;
string field = sender.Field;
MetadataTooltip tooltip = LoadControl("~/Core/DataEntryForms/DataEntryControls/MetadataTooltip.ascx") as MetadataTooltip;
tooltip.BuildTooltipMetadata(table, field, QueryDiseaseName);
this.Controls.Add(tooltip);
}
protected void AssignCheckBoxes(object sender, RepeaterItemEventArgs e)
{
RepeaterItem ItemRow = e.Item;
if (ItemRow.ItemType == ListItemType.Item ||
ItemRow.ItemType == ListItemType.AlternatingItem)
{
ICaisisInputControl cicField = ItemRow.DataItem as ICaisisInputControl;
// Attach event to control item appearance
CheckBox cb = ItemRow.FindControl("CollectOptions") as CheckBox;
if (cb != null)
{
cb.Attributes.Add("onclick", "checkBoxSelectionChanged('" + MainTable.ClientID + "', " + ItemRow.ItemIndex + ",'" + cb.ClientID + "');");
if (cicField != null && cicField.Required)
{
cb.Checked = true;
cb.Attributes["onclick"] = "return handleRequiredSchemaItemCheck(this);";
}
}
if (cicField != null)
{
// Return so option selections are not reloaded
if (IsPostBack)
{
return;
}
string key = "";
foreach (string s in existingData.Keys)
{
key = s;
break;
}
if (existingData.ContainsKey(key))
{
Dictionary <string, DataRow> rowData = existingData[key];
if (rowData.ContainsKey(cicField.Field))
{
DataRow dr = rowData[cicField.Field];
if (dr != null)
{
string val = dr[SchemaItemField.DestValue].ToString();
if (!String.IsNullOrEmpty(val) ||
val == "[enter]")
{
cb.Checked = true;
}
}
}
}
}
}
}
/// <summary>
/// Marks the input field's table as "dirty", i.e., value changed during POSTs
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void MarkTableFieldsDirty(ICaisisInputControl sender, EventArgs e)
{
string table = sender.Table;
if (!string.IsNullOrEmpty(table) && !isTableDirty.ContainsKey(table))
{
isTableDirty.Add(table, true);
}
}
private void AddEntryField(ICaisisInputControl control)
{
// TODO: handle control.Required
if (control.Required)
{
controlsToValidate.Add(control as Control);
}
// TODO: styles and other whatnots
Panel panel = new Panel();
panel.CssClass = "DataEntryRow";
panel.Controls.Add((Control)control);
// Special Cases
if ((MatchProtocol("c12-097") || MatchProtocol("c10-070")) && control.Table == "Status" && control.Field == "Status" && control is ListControl)
{
ListControl listControl = control as ListControl;
listControl.PreRender += (a, b) =>
{
listControl.DataTextField = "";
listControl.DataValueField = "";
listControl.DataSource = PATIENT_STATUSES;
listControl.DataBind();
};
}
else if (MatchProtocol("c12-108") && control.Table == "Categories" && control.Field == "Category" && control is ICaisisLookupControl)
{
// build static data
string[] values = new string[] { "Positive", "Negative" };
DataTable comboData = new DataTable();
comboData.Columns.Add(new DataColumn("Category"));
foreach (string value in values)
{
comboData.Rows.Add(value);
}
CaisisComboBox combo = control as CaisisComboBox;
CaisisSelect select = control as CaisisSelect;
if (combo != null)
{
combo.BuildComboData(comboData, "Category", "Category");
}
else if (select != null)
{
select.PreRender += (a, b) =>
{
select.DataTextField = "Category";
select.DataValueField = "Category";
select.DataSource = comboData;
select.DataBind();
};
}
}
container.Controls.Add(panel);
}
/// <summary>
///
/// </summary>
/// <param name="srcControl"></param>
/// <returns></returns>
public ICaisisInputControl CloneControl(ICaisisInputControl srcControl)
{
ICaisisInputControl clonedCIC = this.InvokeControl();
foreach (CaisisDynamicPropertyModifier dynProp in this.controlGetterSetters.Values)
{
dynProp.CopyField(srcControl, clonedCIC);
}
return(clonedCIC);
}
/// <summary>
///
/// </summary>
/// <param name="src"></param>
/// <param name="dirtyItems"></param>
private void MarkDirtyListItem(ICaisisInputControl src, List <RepeaterItem> dirtyItems)
{
// locate container repeater item
RepeaterItem item = (src as Control).NamingContainer as RepeaterItem;
if (!dirtyItems.Contains(item))
{
dirtyItems.Add(item);
}
}
// copy and paste; ugh, but you c/n override static methods
public static List <ICaisisInputControl> GetCaisisInputControlsByTableName(string tableName)
{
List <ICaisisInputControl> cicList = new List <ICaisisInputControl>();
// get metadata
var fieldMetadata = ProtocolMgmtController.GetTableFieldsMetadata(tableName);
foreach (var field in fieldMetadata)
{
string fieldName = field.Key;
Dictionary <string, string> metadata = new Dictionary <string, string>(field.Value);
bool required = BOL.BusinessObject.IsRequired(tableName, fieldName, null);
string controlType = metadata.ContainsKey(CONTROLTYPE) ? metadata[CONTROLTYPE] : "";
if (controlType.Equals(""))
{
controlType = typeof(CaisisTextBox).Name;
}
// eliminate LookupDistinct that references PatientId, UserName
if (metadata.ContainsKey("LookupDistinct"))
{
string lkpDistint = metadata["LookupDistinct"];
if (!string.IsNullOrEmpty(lkpDistint) && lkpDistint.Contains("@"))
{
metadata.Remove("LookupDistinct");
}
}
ICaisisInputControl cic = InvokeInputControl(controlType);
cic.Field = fieldName;
cic.Table = tableName;
cic.ShowLabel = false;
cic.CssClass = "DynamicControlsClass";
if (cic is WebControl)
{
((WebControl)cic).Style.Add("height", "20px");
}
// set its metadata based attributes
SetCICAttributes(cic, metadata);
// set required from db if not set via metadata
if (!cic.Required && !string.IsNullOrEmpty(tableName) && !string.IsNullOrEmpty(fieldName))
{
if (BOL.BusinessObjectFactory.CanBuildBusinessObject(tableName))
{
cic.Required = BOL.BusinessObject.IsRequired(tableName, fieldName);
}
}
//if (!(cic is CaisisHidden))
cicList.Add(cic);
}
return(cicList);
}
protected void UpdateClick(object sender, EventArgs e)
{
foreach (GridViewRow row in DiseasesGrid.DirtyGridRows)
{
var lookup = CICHelper.GetCaisisInputControlDictionary(row);
int?diseaseId = null;
if (!string.IsNullOrEmpty(lookup[Disease.DiseaseId].Value))
{
diseaseId = int.Parse(lookup[Disease.DiseaseId].Value);
}
string diseaseName = lookup[Disease.DiseaseName].Value;
string diseaseAttributeValueId = lookup[DiseaseAttributeValue.DiseaseAttributeValueId].Value;
string diseaseAttributeValue = (lookup[DiseaseAttributeValue.DiseaseAttributeValue_Field] as CheckBox).Checked.ToString();
ICaisisInputControl isViewAttributeId = lookup[DiseaseAttributeValue.DiseaseAttributeValueId];
CaisisCheckBox isViewAttribute = lookup[DiseaseAttributeValue.DiseaseAttributeValue_Field] as CaisisCheckBox;
// insert/update disease
Disease dBiz = new Disease();
if (diseaseId.HasValue)
{
dBiz.Get(diseaseId.Value);
}
dBiz[Disease.DiseaseName] = diseaseName;
dBiz.Save();
diseaseId = (int)dBiz[Disease.DiseaseId];
// check if disease attribute exists, update
if (isViewAttribute.Checked)
{
if (string.IsNullOrEmpty(isViewAttributeId.Value))
{
DiseaseAttributeValue dav = new DiseaseAttributeValue();
dav[DiseaseAttributeValue.DiseaseId] = diseaseId;
dav[DiseaseAttributeValue.DiseaseAttributeId] = GetDiseaseIsViewAttribute();
dav[DiseaseAttributeValue.DiseaseAttributeValue_Field] = true.ToString().ToLower();
dav.Save();
isViewAttributeId.Value = dav[dav.PrimaryKeyName].ToString();
}
}
else
{
// only delete if key exists
if (!string.IsNullOrEmpty(isViewAttributeId.Value))
{
DiseaseAttributeValue dav = new DiseaseAttributeValue();
dav.Delete(int.Parse(isViewAttributeId.Value));
isViewAttributeId.Value = string.Empty;
}
}
}
Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "reloadMainAdmin", "reloadMainAdmin();", true);
}
