public ComplexListItem(ComplexListItem sourceCLItem)
{
_itemValues = new List<ComplexListItemValue>();
_id = Guid.NewGuid();
_selectable = sourceCLItem._selectable;
_selected = sourceCLItem._selected;
_editable = sourceCLItem._editable;
_deletable = sourceCLItem._deletable;
_default = sourceCLItem._default;
}
public ComplexListItem Migrate(Dictionary<Guid /*destTermField*/, Guid /*sourceTermField*/> fieldMapping, ComplexListItem sourceItem)
{
return null;
}
private void SubstituteComplexLists(Template template)
{
int sampleListItemsOnPreview = 2;
//First, substitute a child clause for each item in each DISTINCT complex list in this clause
string text = Term.SubstituteTermIDs(template, HttpUtility.HtmlDecode(_text));
//NOTE: (RR 2-11-2010) -- added filter to only select complex lists where Runtime.Enabled==true.
List<ComplexList> complexLists = FindComplexLists(template, text).FindAll(cl => cl.Runtime.Enabled == true);
foreach (ComplexList complexList in complexLists)
{
string pattern = string.Format(XMLNames._M_TermImageFindPattern, complexList.Name);
bool inTable = IsInTable(text, complexList.Name);
if (!string.IsNullOrEmpty(complexList.Header))
{
string headerText = (template.IsManagedItem ? complexList.Header : complexList.StandardHeader);
Term.SubstituteBasicTerms(template, ref headerText);
Term.SubstituteSpecialTerms(ref headerText, template);
if (ContainsPrintableCharacters())
{
text = string.Concat(text, HttpUtility.HtmlDecode(headerText));
}
else
{
text = HttpUtility.HtmlDecode(headerText);
}
}
//when doing the preview (i.e. template is NOT a managed item), add sample listitems to the complex list
if (template.IsManagedItem)
{
int index = 0;
for (int i = 0; i < complexList.Items.Count; i++)
{
if (complexList.Items[i].Selected ?? false)
{
if (inTable)
{
string itemDisplayValue = complexList.ItemDisplayValue(complexList.Items[i]);
text = text.Replace(pattern, string.Format("{0}{1}", itemDisplayValue, pattern));
}
else
{
ITATClause childClause = new ITATClause();
childClause.HangingIndent = this.HangingIndent;
childClause.IndentFirstParagraph = this.IndentFirstParagraph;
childClause.IndentSubsequentParagraphs = this.IndentSubsequentParagraphs;
childClause.BreakParagraphs = this.BreakParagraphs;
childClause.PageBreakBefore = false;
childClause.Text = complexList.ItemDisplayValue(complexList.Items[i]);
if (this.ChildNumberingScheme == ChildNumberingSchemeType.None)
childClause.SuppressSpacingBefore = true;
_children.Insert(index, childClause);
index++;
}
}
}
}
else
{
int index = 0;
for (int i = 0; i < sampleListItemsOnPreview; i++)
{
ComplexListItem newItem = new ComplexListItem();
for (int j = 0; j < complexList.Fields.Count; j++)
{
ComplexListField field = complexList.Fields[j];
ComplexListItemValue complexListItemValue = new ComplexListItemValue(field.ID, string.Format(@"<span style=""font-weight:bold; text-decoration:underline;"">{3}{0} #{1} | {2}{4}</span>", complexList.Name, i + 1, field.Name, (char)0xab, (char)0xbb), complexList, field.FilterTerm, true);
newItem.ItemValues.Add(complexListItemValue);
}
if (inTable)
{
text = text.Replace(pattern, string.Format("{0}{1}", complexList.ItemDisplayValue(newItem), pattern));
}
else
{
ITATClause childClause = new ITATClause();
childClause.HangingIndent = this.HangingIndent;
childClause.IndentFirstParagraph = this.IndentFirstParagraph;
childClause.IndentSubsequentParagraphs = this.IndentSubsequentParagraphs;
childClause.BreakParagraphs = this.BreakParagraphs;
childClause.PageBreakBefore = false;
childClause.Text = complexList.ItemDisplayValue(newItem);
_children.Insert(index, childClause);
index++;
}
}
}
//Delete the Complex List Term placeholder from _text
string sOutput = text.Replace(pattern, string.Empty);
_text = HttpUtility.HtmlEncode(sOutput);
}
}
protected void btnOK_Click(object sender, EventArgs e)
{
Business.ComplexList complexList = (Business.ComplexList)_template.ComplexLists[TermIndex];
List<ComplexListItemValue> complexListItemValues = new List<ComplexListItemValue>();
foreach (Business.ComplexListField field in complexList.Fields)
{
ComplexListItemValue cliv = new ComplexListItemValue(complexList, field.FilterTerm);
cliv.FieldID = field.ID;
cliv.FieldValue = GetFieldValue(field);
cliv.BigText = cliv.FieldValue.Length > 150;
complexListItemValues.Add(cliv);
}
ComplexListItem complexListItem = new ComplexListItem();
complexListItem.Default = true;
complexListItem.ItemValues = complexListItemValues;
complexListItem.Selectable = chkbxSelectable.Checked;
complexListItem.Selected = chkbxSelected.Checked;
complexListItem.Editable = chkbxEditable.Checked;
complexListItem.Deletable = chkbxDeletable.Checked;
if (EditMode == EditMode.Add)
complexList.Items.Add(complexListItem);
else
complexList.Items[termEdit.ComplexListItemIndex] = complexListItem;
BaseTransfer(null, TermHandler.ComplexListItem, "TermEditComplexListItems.aspx", true);
}
public override void Migrate(Term term)
{
if (term == null)
base.Migrate(term);
if (!(term is ComplexList))
return;
else
{
ComplexList sourceTerm = term as ComplexList;
//Any Items found within the destination term ComplexList are considered Default Items. If there are no Default Items, then
//migrate the sourceTerm ComplexList Items. If there are Default Items, then do not migrate the source term ComplexList Items.
if (ModifyItems(sourceTerm, this))
{
//Migrate the sourceTerm Items. First, create a mapping of FieldID's. Match source to destination based on ID, then by name.
Dictionary<Guid /*destCLFieldID*/, ComplexListField /*sourceCLField*/> fieldMapping = new Dictionary<Guid, ComplexListField>();
foreach (ComplexListField destCLField in Fields)
{
ComplexListField sourceCLField = sourceTerm.FindField(destCLField.ID);
if (sourceCLField == null)
sourceCLField = sourceTerm.FindField(destCLField.Name);
if (sourceCLField != null)
fieldMapping.Add(destCLField.ID, sourceCLField);
else
fieldMapping.Add(destCLField.ID, destCLField);
}
foreach (ComplexListItem sourceCLItem in sourceTerm.Items)
{
ComplexListItem destCLItem = new ComplexListItem(sourceCLItem);
foreach (ComplexListField destCLField in Fields)
{
ComplexListItemValue destCLItemValue = new ComplexListItemValue(null, destCLField.FilterTerm);
destCLItemValue.BigText = fieldMapping[destCLField.ID].BigText ?? false;
destCLItemValue.RemoveBlank = fieldMapping[destCLField.ID].RemoveBlank ?? false;
destCLItemValue.FieldID = destCLField.ID;
ComplexListItemValue sourceCLItemValue = sourceCLItem.FindItemValue(fieldMapping[destCLField.ID].ID);
if (sourceCLItemValue != null)
destCLItemValue.Migrate(sourceCLItemValue);
else
destCLItemValue.Clear();
destCLItem.ItemValues.Add(destCLItemValue);
}
Items.Add(destCLItem);
}
}
sourceTerm.Runtime.Migrated = true;
}
Runtime.Migrated = true;
}
private string SubstituteItemValue(ComplexListItem item, string fieldName)
{
try
{
for (int i = 0; i < item.ItemValues.Count; i++)
if (this.Fields[i].Name == fieldName)
if (item.ItemValues[i].RemoveBlank)
if (string.IsNullOrEmpty(item.ItemValues[i].DisplayValue))
return string.Empty;
else
return item.ItemValues[i].DisplayValue;
else
return item.ItemValues[i].DisplayValue;
return string.Empty;
}
catch
{
return string.Empty;
}
}
private string SubstituteTerms(ComplexListItem item)
{
//match anything of the form <img...src="TextImage.ashx?text="...".../> in _text
string text = HttpUtility.HtmlDecode(this.Rendering);
if (!string.IsNullOrEmpty(text))
{
MatchCollection matches = Regex.Matches(text, XMLNames._M_TermImageTemplate);
foreach (Match match in matches)
{
string matchedText = match.Result("$0");
string fieldName = match.Groups[1].Value;
string replacementText = SubstituteItemValue(item, fieldName);
text = HttpUtility.HtmlDecode(text).Replace(matchedText, replacementText);
}
}
return text;
}
public string ItemDisplayValue(ComplexListItem item)
{
string rtn = SubstituteTerms(item);
return rtn;
}
public ComplexList(XmlNode node, Template template, bool isFilter)
: base(node, template, isFilter)
{
TermType = TermType.ComplexList;
NameRequired = true;
_columnCount = Utility.XMLHelper.GetAttributeInt(node, XMLNames._A_ColumnCount);
_showOnItemSummary = Utility.XMLHelper.GetAttributeBool(node, XMLNames._A_ShowOnItemSummary);
_fields = new List<ComplexListField>();
XmlNodeList nodeFields = node.SelectNodes(Utility.XMLHelper.GetXPath(false, XMLNames._E_Fields, XMLNames._E_Field));
if (nodeFields != null)
{
foreach (XmlNode nodeField in nodeFields)
{
ComplexListField field = new ComplexListField(nodeField, this);
_fields.Add(field);
}
}
_items = new List<ComplexListItem>();
XmlNodeList nodeItems = node.SelectNodes(Utility.XMLHelper.GetXPath(false, XMLNames._E_Items, XMLNames._E_Item));
if (nodeItems != null)
{
foreach (XmlNode nodeItem in nodeItems)
{
ComplexListItem item = new ComplexListItem(nodeItem, this);
//Set the BigText value stored within each itemValue - for use by the interface
foreach (ComplexListItemValue itemValue in item.ItemValues)
{
if (!itemValue.FieldIDDefined)
{
itemValue.BigText = FindField(itemValue.FieldName).BigText ?? false;
itemValue.RemoveBlank = FindField(itemValue.FieldName).RemoveBlank ?? false;
}
else
{
itemValue.BigText = FindField(itemValue.FieldID).BigText ?? false;
itemValue.RemoveBlank = FindField(itemValue.FieldID).RemoveBlank ?? false;
}
}
_items.Add(item);
}
}
foreach (ComplexListItem item in _items)
{
foreach (ComplexListItemValue itemValue in item.ItemValues)
{
if (!itemValue.FieldIDDefined)
{
itemValue.FieldID = FindField(itemValue.FieldName).ID;
}
}
}
XmlNode nodeRendering = node.SelectSingleNode(XMLNames._E_Rendering);
if (nodeRendering != null)
{
_rendering = Utility.XMLHelper.GetText(nodeRendering);
_rendering = ComplexListField.EmbedFieldNames(this, _rendering);
}
XmlNode nodeStandardHeader = node.SelectSingleNode(XMLNames._E_StandardHeader);
if (nodeStandardHeader != null)
{
_standardHeader = Utility.XMLHelper.GetText(nodeStandardHeader);
_standardHeader = ComplexListField.EmbedFieldNames(this, _standardHeader);
}
XmlNode nodeAlternateHeader = node.SelectSingleNode(XMLNames._E_AlternateHeader);
if (nodeAlternateHeader != null)
{
_alternateHeader = Utility.XMLHelper.GetText(nodeAlternateHeader);
_alternateHeader = ComplexListField.EmbedFieldNames(this, _alternateHeader);
}
}