public ITATDocument() { _ITATDocumentID = Guid.NewGuid(); _documentName = string.Empty; _defaultDocument = false; _workflowEnabled = true; _clause = new ITATClause(); _clause.Name = XMLNames._E_Document; _header = new ITATDocumentHeader(); _footer = new ITATDocumentFooter(); }
private bool FormChanged(ITATClause clause) { if (clause.Name != txtName.Text) { //TODO: rename the appropriate tree node that was changed return true; } if (clause.ChildNumberingScheme != (Business.ChildNumberingSchemeType)Enum.Parse(typeof(Business.ChildNumberingSchemeType), ddlChildNumberingScheme.SelectedValue)) return true; if ((clause.IndentFirstParagraph ?? false) != chkIndentFirstParagraph.Checked) return true; if ((clause.IndentSubsequentParagraphs ?? false) != chkIndentSubsequentParagraphs.Checked) return true; if ((clause.HangingIndent ?? false) != chkHangingIndent.Checked) return true; if ((clause.BreakParagraphs ?? false) != chkBreakParagraphs.Checked) return true; if ((clause.PageBreakBefore ?? false) != chkPageBreakBefore.Checked) return true; //in the next 3 "if" blocks, ignore the case where one string is null and the other is empty if (_template.MatchTerm(clause.DependsOnTermID, clause.DependsOnTermName, ddlConditionalTerm.SelectedValue)) return true; if (clause.DependsOnOperator != ddlConditionalOperator.SelectedValue) if (!(string.IsNullOrEmpty(clause.DependsOnOperator) && string.IsNullOrEmpty(ddlConditionalOperator.SelectedValue))) //ignore the case where one string is null and the other is empty return true; if (clause.DependsOnValue != ddlConditionalValue.SelectedValue) if (!(string.IsNullOrEmpty(clause.DependsOnValue) && string.IsNullOrEmpty(ddlConditionalValue.SelectedValue))) //ignore the case where one string is null and the other is empty return true; return false; }
public ITATDocument(XmlDocument xmlTemplateDoc, XmlNode node, Template template, bool isNewDocStructure) { if (isNewDocStructure) { _ITATDocumentID = new Guid(Utility.XMLHelper.GetAttributeString(node, XMLNames._A_ID)); _documentName = Utility.XMLHelper.GetAttributeString(node, XMLNames._A_Name); _defaultDocument = Utility.XMLHelper.GetAttributeBool(node, XMLNames._A_Document_DefaultDocument); _workflowEnabled = Utility.XMLHelper.GetAttributeBool(node, XMLNames._A_Document_WorkflowEnabled); _generatedDocumentID = Utility.XMLHelper.GetAttributeString(node, XMLNames._A_GeneratedDocumentID); } else { _ITATDocumentID = Guid.NewGuid(); _documentName = Utility.XMLHelper.GetAttributeString(node.SelectSingleNode(XMLNames._E_Body), XMLNames._A_Name); _defaultDocument = true; _workflowEnabled = true; _generatedDocumentID = Utility.XMLHelper.GetAttributeString(xmlTemplateDoc.DocumentElement, XMLNames._A_GeneratedDocument); ; } XmlNode nodeHeader = node.SelectSingleNode(XMLNames._E_Header); _header = new ITATDocumentHeader(nodeHeader); XmlNode nodeFooter = node.SelectSingleNode(XMLNames._E_Footer); _footer = new ITATDocumentFooter(nodeFooter); XmlNode nodeBody = node.SelectSingleNode(XMLNames._E_Body); _clause = new ITATClause(); _clause.Name = Utility.XMLHelper.GetAttributeString(nodeBody, XMLNames._A_Name); _clause.ChildNumberingScheme = ChildNumberingSchemeHelper.GetSchemeType(Utility.XMLHelper.GetAttributeString(nodeBody, XMLNames._A_ChildNumberingScheme)); _clause.Create(nodeBody); }
private void LoadClauseProperties(ITATClause clause, bool rootNode) { txtName.Text = clause.Name; ddlChildNumberingScheme.SelectedValue = clause.ChildNumberingScheme.ToString("D"); if (rootNode) { lblName.Visible = false; txtName.Visible = false; chkIndentFirstParagraph.Visible = false; chkIndentSubsequentParagraphs.Visible = false; chkHangingIndent.Visible = false; chkBreakParagraphs.Visible = false; chkPageBreakBefore.Visible = false; ddlConditionalTerm.Visible = false; spnDependsOn.Visible = false; fldDependsOn.Visible = false; } else { chkIndentFirstParagraph.Checked = (clause.IndentFirstParagraph ?? false); chkIndentSubsequentParagraphs.Checked = (clause.IndentSubsequentParagraphs ?? false); chkHangingIndent.Checked = (clause.HangingIndent ?? false); chkBreakParagraphs.Checked = (clause.BreakParagraphs ?? false); chkPageBreakBefore.Checked = (clause.PageBreakBefore ?? false); string dependsOnTermName = _template.FindTermName(clause.DependsOnTermID, clause.DependsOnTermName); FormatDependentClauseSection(dependsOnTermName, clause.DependsOnOperator, clause.DependsOnValue); txtName.Visible = true; lblName.Visible = true; chkIndentFirstParagraph.Visible = true; chkIndentSubsequentParagraphs.Visible = true; chkHangingIndent.Visible = true; chkBreakParagraphs.Visible = true; chkPageBreakBefore.Visible = true; ddlConditionalTerm.Visible = true; spnDependsOn.Visible = true; fldDependsOn.Visible = true; } }
protected void btnAddClause_OnCommand(object sender, CommandEventArgs e) { ITATClause parent = _template.GetITATDocument(_ITATDocumentID).FindClause(_clausePath, treClauses.PathSeparator); ITATClause newClause = new ITATClause(); newClause.Name = "New Clause"; newClause.ChildNumberingScheme = ChildNumberingSchemeType.None; newClause.Text = Helper.DefaultEditorHtml(edt); parent.Children.Add(newClause); LoadClauseTree(); //refresh the clause tree to pick up the new clause SelectTreeNode(string.Format("{0}{2}{1}", _clausePath, newClause.Name, treClauses.PathSeparator)); IsChanged = true; }
private void AddTreeNode(TreeNode parent, ITATClause clause) { TreeNode newNode; if (parent == null) { newNode = new TreeNode(clause.Name, clause.Name); treClauses.Nodes.Add(newNode); } else { newNode = new TreeNode(clause.Name, clause.Name); parent.ChildNodes.Add(newNode); } //newNode.NavigateUrl = string.Format("javascript:OnTreeNodeClick('{0}')", clause.Name); foreach (ITATClause childClause in clause.Children) AddTreeNode(newNode, childClause); }
private void LoadClauseText(ITATClause clause) { edt.Visible = true; edt.Html = Business.Term.SubstituteTermIDs(_template, clause.Text); }
public static void ReplaceEmbeddedTermNames(Template template, ITATClause child, List<string> sErrors) { if (!string.IsNullOrEmpty(child.DependsOnTermName)) { try { child.DependsOnTermID = template.FindTerm(child.DependsOnTermName).ID; } catch (Exception) { sErrors.Add(string.Format("Unable to find Clause Dependent term '{0}'", child.DependsOnTermName)); } } for (int i = 0; i < child._children.Count; i++) { if (!string.IsNullOrEmpty(child._children[i].DependsOnTermName)) { try { child._children[i].DependsOnTermID = template.FindTerm(child._children[i].DependsOnTermName).ID; } catch (Exception) { sErrors.Add(string.Format("Unable to find Clause Dependent term '{0}'", child._children[i].DependsOnTermName)); } } } }
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); } }
public static void SubstituteTermNames(Template template, ITATClause child) { child.Text = Term.SubstituteTermNames(template, child.Text); for (int i = 0; i < child._children.Count; i++) { child._children[i].Text = Term.SubstituteTermNames(template, child._children[i].Text); } }
public void Build(XmlDocument xmlDoc, XmlNode parentNode, ITATClause parentClause, bool bValidate) { foreach (ITATClause childClause in parentClause._children) { if (bValidate) { Utility.XMLHelper.ValidateString("ITATClause text", childClause._text); } XmlNode elementChildClause = xmlDoc.CreateNode(XmlNodeType.Element, XMLNames._E_Clause, XMLNames._M_NameSpaceURI); BuildNode(xmlDoc, elementChildClause, childClause, bValidate); Build(xmlDoc, elementChildClause, childClause, bValidate); parentNode.AppendChild(elementChildClause); } }
public void BuildNode(XmlDocument xmlDoc, XmlNode node, ITATClause clause, bool bValidate) { if (bValidate) { if (string.IsNullOrEmpty(clause._text)) throw new XmlException("Required ITATClause text not supplied"); } Utility.XMLHelper.AddAttributeString(xmlDoc, node, XMLNames._A_Name, clause._name); Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_IndentFirstParagraph, clause._indentFirstParagraph); Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_IndentSubsequentParagraphs, clause._indentSubsequentParagraphs); Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_HangingIndent, clause._hangingIndent); Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_BreakParagraphs, clause._breakParagraphs); Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_PageBreakBefore, clause._pageBreakBefore); Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_SuppressSpacingBefore, clause._suppressSpacingBefore); Term.StoreID(xmlDoc, node, XMLNames._A_DependsOnTermName, clause._dependsOnTermName, XMLNames._A_DependsOnTermID, clause._dependsOnTermID); Utility.XMLHelper.AddAttributeString(xmlDoc, node, XMLNames._A_DependsOnOperator, clause._dependsOnOperator); Utility.XMLHelper.AddAttributeString(xmlDoc, node, XMLNames._A_DependsOnValue, clause._dependsOnValue); Utility.XMLHelper.AddAttributeString(xmlDoc, node, XMLNames._A_ChildNumberingScheme, ChildNumberingSchemeHelper.GetSchemeText(clause._childNumberingScheme)); Utility.XMLHelper.AddText(xmlDoc, node, clause._text); }
private bool ParseDOM(XmlNode parentNode, ITATClause parentClause) { foreach (XmlNode childNode in parentNode.ChildNodes) { if (!Utility.XMLHelper.IsTextNode(childNode)) { ITATClause childClause = new ITATClause(); childClause.CreateNode(childNode, childClause); childClause._parent = parentClause; parentClause._children.Add(childClause); } } return true; }
private bool CreateNode(XmlNode clauseNode, ITATClause clause) { clause._name = Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_Name); clause._indentFirstParagraph = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_IndentFirstParagraph); clause._indentSubsequentParagraphs = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_IndentSubsequentParagraphs); clause._hangingIndent = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_HangingIndent); clause._breakParagraphs = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_BreakParagraphs); clause._pageBreakBefore = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_PageBreakBefore); clause._suppressSpacingBefore = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_SuppressSpacingBefore); clause._dependsOnTermName = Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_DependsOnTermName); clause._dependsOnTermID = Term.CreateID(clauseNode, XMLNames._A_DependsOnTermID); clause._dependsOnOperator = Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_DependsOnOperator); clause._dependsOnValue = Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_DependsOnValue); clause._childNumberingScheme = ChildNumberingSchemeHelper.GetSchemeType(Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_ChildNumberingScheme)); clause._text = Utility.XMLHelper.GetText(clauseNode); return ParseDOM(clauseNode, clause); }