private static XmlSchemaElement SerializeToXmlSchemaElement(IPluglet pluglet) { XmlSchemaElement element = new XmlSchemaElement(); element.Name = pluglet.Name; SetMinAndMaxOccurs(pluglet, element); SetDocumentation(pluglet, element); //Generate complex type for every node other than data if (pluglet.PlugletType != PlugletType.Data && pluglet.Children != null && pluglet.Children.Count > 0) { XmlSchemaComplexType complexType = new XmlSchemaComplexType(); element.SchemaType = complexType; XmlSchemaSequence sequence = new XmlSchemaSequence(); complexType.Particle = sequence; foreach (IPluglet child in pluglet.Children) { XmlSchemaElement childElement = SerializeToXmlSchemaElement(child); sequence.Items.Add(childElement); } } //generate SimpleType else { XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(); element.SchemaType = simpleType; XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); simpleType.Content = restriction; SetAppInfoAndDataType(pluglet, element); } return(element); }
/// <summary> /// Clone IPluglet /// </summary> /// <param name="pluglet"></param> /// <param name="withChild">True if childs also need to be cloned</param> /// <returns></returns> public static Pluglet Clone(this IPluglet pluglet, bool withChild) { Pluglet newPluglet = new Pluglet(pluglet.Name, pluglet.Definition, pluglet.PlugletType, null, pluglet.RepetitionInfo.MinOccurs, pluglet.RepetitionInfo.MaxOccurs); newPluglet.DataType = pluglet.DataType; newPluglet.IsRecursiveMandatory = pluglet.IsRecursiveMandatory; if (pluglet.Attributes != null) { foreach (IPluglet attr in pluglet.Attributes) { newPluglet.Attributes.Add(attr.Clone(false)); } } if (withChild && pluglet.Children != null) { foreach (Pluglet child in pluglet.Children) { newPluglet.Children.Add(child.Clone(withChild)); } } return(newPluglet); }
private void CheckMissingMandatoryElements(IPluglet currentPluglet, IDocumentFragment currentDocumentFragment) { foreach (IPluglet childPluglet in currentPluglet.Children) { if (childPluglet.IsMandatory == false) { continue; } bool childExist = false; foreach (IDocumentFragment childDocumentFragment in currentDocumentFragment.Children) { if (childDocumentFragment.Pluglet.Tag == childPluglet.Tag) { childExist = true; break; } } EdiErrorType errorType = EdiErrorType.Error; if (childPluglet.IsIgnore) { errorType = EdiErrorType.Warning; } if (childExist == false) { Errors.AddSegmentError(childPluglet.Tag, X12ErrorCode.MandatorySegmentMissingCode , string.Format("{0} : {1}", X12ErrorCode.GetStandardSegmentErrorDescription(X12ErrorCode.MandatorySegmentMissingCode), childPluglet.Tag) , CurrentElementNumber, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength, errorType); } } }
/// <summary> /// Get the sibling of current pluglet /// </summary> /// <param name="currentPluglet"></param> public static IPluglet GetSibling(this IPluglet currentPluglet) { if (currentPluglet == null) { throw new ArgumentNullException("currentPluglet"); } IPluglet nextPluglet = currentPluglet.Parent; if (nextPluglet != null) { // Get next child of the parent of currentPluglet int i = 0; for (i = 0; i < nextPluglet.Children.Count; i++) { if (nextPluglet.Children[i] == currentPluglet) { break; } } // if currentPluglet is not the last child of it's parent, return next child if (i < nextPluglet.Children.Count - 1) { nextPluglet = nextPluglet.Children[i + 1]; } else { nextPluglet = null; } } return(nextPluglet); }
private static string GetLoopName(IPluglet parent) { string loopName = string.Empty; int level = 0; while (parent.PlugletType == PlugletType.Loop && parent.Parent != null) { if (level == 0) { loopName = parent.Name; } else { loopName = string.Format("{0}->{1}", parent.Name, loopName); } level++; if (level == SupportedNestedLevels) { break; } parent = parent.Parent; } return(loopName); }
private static IDocumentPlug ParseSchema(XmlQualifiedName rootElement, XmlSchema schema) { IDocumentPlug plug = new DocumentPlug(); IPluglet root = null; if (schema == null) { plug.Error.Add("SchemaCode101ENullSchema"); return(plug); } // Extract the root element XmlSchemaElement elem = (XmlSchemaElement)schema.Elements[rootElement]; if (elem != null) { root = ParseElement(null, elem, schema); } else { plug.Error.Add("SchemaCode102ENullRootElement"); } plug.RootPluglet = root; return(plug); }
protected override DocumentPlug ConstructDocumentPlug(ExcelWorksheet schemaWorksheet, int startRow) { Pluglet rootPluglet = new Pluglet("X12", "GC root Node", PlugletType.Loop, null, 1, -1); DocumentPlug documentPlug = new DocumentPlug(rootPluglet, BusinessDomain.FlatFile); ReadMetadata(documentPlug, schemaWorksheet); string currentLoopName = string.Empty; string nextLoopName; IPluglet loopPluglet = null; IPluglet nextPluglet; int minOccurs, maxOccurs; int row = startRow; while ((nextPluglet = GetSegment(schemaWorksheet, ref row, out nextLoopName)) != null) { // In case of flat file, we do not have loops rootPluglet.Children.Add(nextPluglet); nextPluglet.Parent = rootPluglet; } return(documentPlug); }
private static void PrintDocumentPlug(IPluglet root, StringBuilder sb, int indent) { //Format1 //for (int i = 0; i < indent; i++) sb.Append("\t"); //string data = string.Format(Format1Indented, root.Name, root.Description, root.PlugletType, root.IsMandatory); //sb.Append(data); //sb.AppendLine(); //end Format1 //Format2 string description = root.Definition; if (!string.IsNullOrEmpty(description)) { description = description.Replace(' ', '#'); } string data = string.Format(Format2Flat, root.PlugletType, root.IsRecursiveMandatory ? "Y" : "N", description); sb.Append(data); for (int i = 0; i < indent; i++) { sb.Append("\t"); } sb.Append(root.Name); sb.AppendLine(); //end Format2 foreach (IPluglet child in root.Children) { PrintDocumentPlug(child, sb, indent + 1); } }
/// <summary> /// Find out the node in tree for a given xPath /// </summary> /// <param name="currentPluget"></param> /// <param name="xPath"></param> /// <returns></returns> public static IPluglet MoveTo(this IPluglet rootPluget, string xPath) { if (rootPluget == null) { return(null); } IPluglet pluglet = null; string[] pathElements = xPath.Split(new string[] { rootPluget.PathSeperator }, StringSplitOptions.None); // Check if root element and 1st element in path match if (string.Equals(pathElements[0], rootPluget.Name, StringComparison.OrdinalIgnoreCase) == false) { throw new PlugDataModelException( string.Format("Error while traversing path {0}. First element in path {1} does not match with root element {2} of document", xPath, pathElements[0], rootPluget.Name)); } IPluglet prevPluglet = rootPluget; //code to load attributes in a dictionary Dictionary <string, string> attributes = new Dictionary <string, string>(); foreach (IPluglet attr in prevPluglet.Attributes) { string name = attr.Name; name = name.Remove(0, 1); name = name.Remove(name.Length - 1, 1); attributes.Add(name, name); } for (int i = 1; i < pathElements.Length; i++) { pluglet = prevPluglet.Children.FirstOrDefault( f => string.Equals(f.Name, pathElements[i], StringComparison.OrdinalIgnoreCase)); if (pluglet == null) { // Check if this is last pathElement and if it is then check if // it's attributes if (i == pathElements.Length - 1 && prevPluglet.Attributes != null && attributes.ContainsKey(pathElements[i])) { pluglet = prevPluglet; } else { throw new PlugDataModelException( string.Format("Error while traversing path {0}. {1} node not found", xPath, pathElements[i])); } } prevPluglet = pluglet; } return(pluglet); }
/// <summary> /// Search for segment pluglet matching segmentName from given currentPluglet. Search left side of current pluglet. /// </summary> /// <param name="currentPluglet"></param> /// <param name="segmentName"></param> /// <param name="missingMandatorySegments"></param> /// <returns></returns> public static IPluglet FindPlugletBefore(this IPluglet currentPluglet, string segmentName, string[] segmentDetails, out string missingMandatorySegments) { bool ignoreOccurrenceCheck = true; missingMandatorySegments = string.Empty; if (currentPluglet == null || currentPluglet.Parent == null || currentPluglet.Parent.Children.Count < 2) { return(null); } string tmpMissingMandatorySegments; IPluglet tmpPluglet; foreach (IPluglet child in currentPluglet.Parent.Children) { // Compare pluglets till current pluglet only // TODO: Check if we need reference equality here if (child == currentPluglet) { break; } if (child.PlugletType == PlugletType.Segment || child.PlugletType == PlugletType.CompositeData) { if (child.IsSameSegment(segmentName, segmentDetails, ignoreOccurrenceCheck)) { return(child); } // TODO: Mandatory and IsIgnore is confusing in one if statement // Mandatory actually indicate that partner will accept this segment if (child.IsMandatory && child.IsIgnore == false) { missingMandatorySegments = JoinCSVList(missingMandatorySegments, child.Tag); } } else // for loops { tmpPluglet = child.FindInSubTree(segmentName, segmentDetails, ignoreOccurrenceCheck, out tmpMissingMandatorySegments); // Check if we need to include missing mandatory segments // TODO: Mandatory and IsIgnore is confusing in one if statement // Mandatory actually indicate that partner will accept this segment if ((child.IsMandatory && child.IsIgnore == false) || tmpPluglet != null) { missingMandatorySegments = JoinCSVList(missingMandatorySegments, tmpMissingMandatorySegments); } if (tmpPluglet != null) { return(tmpPluglet); } } } return(null); }
protected static void FillInMissingChildren(IPluglet segment) { IList <IPluglet> inputList = segment.Children; int origLength = inputList.Count; if (origLength < 2) { return; } int visitIndex = 0; string prefix; int expectedNumber = GetSequenceNumber(inputList[0].Name, out prefix); int visitedNodeNumber; int numberOfNodesVisited = 0; while (numberOfNodesVisited < origLength) { visitedNodeNumber = GetSequenceNumber(inputList[visitIndex].Name, out prefix); numberOfNodesVisited++; //initialize the sequence if (visitedNodeNumber >= 0 && expectedNumber < 0) { expectedNumber = visitedNodeNumber; } //if a gap in sequence space is found if (visitedNodeNumber > expectedNumber) { //fill in the range of numbers from expectedNumber to (visitedNodeNumber-1) for (int fillCount = 0; fillCount <= visitedNodeNumber - 1 - expectedNumber; fillCount++) { string newNodeName = GenerateName(prefix, expectedNumber + fillCount); //more formally consturct a new node here using appropriate constructor IPluglet child = new Pluglet(newNodeName, newNodeName, PlugletType.Data, null, 0, 1, true); child.DataType = new X12_AnDataType("AN", -1, -1); inputList.Insert(visitIndex + fillCount, child); child.Parent = segment; } visitIndex += visitedNodeNumber - expectedNumber + 1; expectedNumber = visitedNodeNumber + 1; } else { visitIndex++; if (expectedNumber >= 0) { expectedNumber++; } } } }
public IDocumentFragment createDocumentFragment(IPluglet root, XmlNodeList nodes) { DocumentFragment docFrag = new DocumentFragment(); IPluglet result = extractPluglet(root, nodes[0], this.plug); docFrag.Pluglet = result; docFrag.Parent = null; createDocumentFragment(root, nodes[0], docFrag); return(docFrag); }
public static bool IsSameSegment(this IPluglet pluglet, string segmentName, string[] segmentDetails, bool ignoreOccurrenceCheck) { bool isSameSegment = false; if (pluglet.PlugletType == PlugletType.Segment || pluglet.PlugletType == PlugletType.CompositeData) { // Set currentOccur based on number of occurances // option-1 (not clean design, but quick and dirty) - Maintain count in IPluglet and reset it on EDIReader.Initialize // option-2 - Refer to document fragment (result of EDI reader) and get current occurrence count int currentOccur = pluglet.CurrentOccurrences; if (string.Equals(pluglet.Tag, segmentName, StringComparison.InvariantCultureIgnoreCase) && (ignoreOccurrenceCheck == true || (currentOccur == 0 || (pluglet.IsRepeatable && (pluglet.RepetitionInfo.MaxOccurs == -1 || pluglet.RepetitionInfo.MaxOccurs > currentOccur))))) { if (pluglet.ContainsTriggerChildField) { for (int i = 0; i < pluglet.Children.Count; i++) { IPluglet child = pluglet.Children[i]; if (child.IsTriggerField) { // For trigger field pluglet should is of type ID (enum) and one of the value should match the dataSegmentValue X12_IdDataType dataType = child.DataType as X12_IdDataType; if (dataType != null && (i + 1) < segmentDetails.Length && !string.IsNullOrWhiteSpace(segmentDetails[i + 1])) { string dataSegmentValue = segmentDetails[i + 1].Trim().ToUpperInvariant(); foreach (string value in dataType.AllowedValues.Keys) { if (value.ToUpperInvariant().Equals(dataSegmentValue)) { isSameSegment = true; break; } } break; } } } } else { isSameSegment = true; } } } return(isSameSegment); }
private static void SetDocumentation(IPluglet pluglet, XmlSchemaElement element) { if (!string.IsNullOrEmpty(pluglet.Definition)) { XmlSchemaAnnotation annotation = new XmlSchemaAnnotation(); XmlSchemaDocumentation doc = new XmlSchemaDocumentation(); doc.Markup = TextToNodeArray(pluglet.Definition); annotation.Items.Add(doc); element.Annotation = annotation; } }
private static void SetParent(this IPluglet pluglet, IPluglet parent) { pluglet.Parent = parent; if (pluglet.Children != null) { foreach (IPluglet child in pluglet.Children) { child.SetParent(pluglet); } } }
// Depreciated - Use Pluglet(PlugletInput) instead public Pluglet(string name, string definition, PlugletType type, IPluglet parent, int minOccurs, int maxOccurs, bool isIgnore) : this(new PlugletInput() { Name = name, Definition = definition, Type = type, Parent = parent, MinOccurs = minOccurs, MaxOccurs = maxOccurs, IsIgnore = isIgnore, }) { }
/// <summary> /// Remove loops from pluglet /// </summary> /// <param name="pluglet"></param> /// <param name="canonicalPluglet"></param> /// <returns></returns> public static Pluglet RemoveLoops(this IPluglet pluglet, IPluglet canonicalPluglet) { if (pluglet == null) { throw new ArgumentNullException("pluglet"); } Pluglet resultPluglet = pluglet.Clone(false); if (pluglet.Children != null && pluglet.Children.Count > 0) { int childIndex; IPluglet prevChild, mergedChild, canonicalChildPluglet = null; prevChild = mergedChild = canonicalChildPluglet = null; for (childIndex = 0; childIndex < pluglet.Children.Count; childIndex++) { canonicalChildPluglet = canonicalPluglet.Children.First(p => p.Name == pluglet.Children[childIndex].Name); pluglet.Children[childIndex] = pluglet.Children[childIndex].RemoveLoops(canonicalChildPluglet); if (prevChild != null) { if (string.Equals(prevChild.Name, pluglet.Children[childIndex].Name, StringComparison.OrdinalIgnoreCase)) { mergedChild = mergedChild.Merge(pluglet.Children[childIndex], canonicalChildPluglet); } else { resultPluglet.Children.Add(mergedChild); mergedChild = null; } } prevChild = pluglet.Children[childIndex]; if (mergedChild == null) { mergedChild = pluglet.Children[childIndex]; } } if (mergedChild == null) { mergedChild = pluglet.Children[childIndex - 1]; } resultPluglet.Children.Add(mergedChild); } return(resultPluglet); }
private static void SetAppInfoAndDataType(IPluglet pluglet, XmlSchemaElement element) { X12BaseDataType dataType = pluglet.DataType; if (dataType != null && !string.IsNullOrEmpty(dataType.Name)) { XmlSchemaAppInfo appInfo = new XmlSchemaAppInfo(); XmlDocument doc = new XmlDocument(); XmlElement elem = doc.CreateElement("STD_Info"); elem.SetAttribute("DataType", dataType.Name); if (!string.IsNullOrEmpty(pluglet.DEStandard)) { elem.SetAttribute("Name", pluglet.DEStandard); } if (!string.IsNullOrEmpty(pluglet.DENumber)) { elem.SetAttribute("Number", pluglet.DENumber); } if (dataType.MaxLength > 0) { elem.SetAttribute("MaximumLength", dataType.MaxLength.ToString()); } XmlNode[] nodeArray = new XmlNode[1] { elem }; appInfo.Markup = nodeArray; if (element.Annotation != null) { element.Annotation.Items.Add(appInfo); } else { XmlSchemaAnnotation annotation = new XmlSchemaAnnotation(); annotation.Items.Add(appInfo); element.Annotation = annotation; } if (string.Equals(dataType.Name, X12DataTypeFactory.IDNew_DataTypeName, StringComparison.OrdinalIgnoreCase)) { PopulateEnumerationValues(pluglet.DataType as X12_IdDataType, element); } } }
public void validation(XmlNodeList nodes, IPluglet root) { foreach (XmlNode node in nodes) { // Console.WriteLine("Validating node " + node.Name); if (!node.FirstChild.HasChildNodes) { continue; } IPluglet result = extractPluglet(root, node, this.plug); validateChild(result.Children, node.ChildNodes, result.PlugletType, 0, false); validation(node.ChildNodes, root); } }
public static XmlSchema SerializeToXSD(IDocumentPlug plug) { IPluglet pluglet = plug.RootPluglet; if (pluglet == null) { return(null); } XmlSchema schema = new XmlSchema(); XmlSchemaElement rootElement = SerializeToXmlSchemaElement(pluglet); schema.Items.Add(rootElement); return(schema); }
public static void ResetCurrentOccurances(this IPluglet pluglet) { if (pluglet == null) { return; } pluglet.CurrentOccurrences = 0; if (pluglet.Children != null) { foreach (IPluglet child in pluglet.Children) { child.ResetCurrentOccurances(); } } }
/// <summary> /// Search for a given segment in subtree of currentPluglet /// </summary> /// <param name="currentPluglet"></param> /// <param name="segmentName"></param> /// <param name="missingMandatorySegments"></param> /// <returns></returns> public static IPluglet FindInSubTree(this IPluglet currentPluglet, string segmentName, string[] segmentDetails, bool ignoreOccurrenceCheck, out string missingMandatorySegments) { missingMandatorySegments = string.Empty; if (currentPluglet == null) { throw new ArgumentNullException("currentPluglet"); } if (currentPluglet.IsSameSegment(segmentName, segmentDetails, ignoreOccurrenceCheck)) { return(currentPluglet); } if (currentPluglet.IsMandatory && currentPluglet.IsIgnore == false && currentPluglet.PlugletType == PlugletType.Segment) { missingMandatorySegments = currentPluglet.Name; } //if all child nodes are data element then return null if (currentPluglet.Children == null || currentPluglet.Children.All(n => n.PlugletType == PlugletType.Data)) { return(null); } string tmpMissingMandatorySegments; foreach (IPluglet child in currentPluglet.Children) { IPluglet node = child.FindInSubTree(segmentName, segmentDetails, ignoreOccurrenceCheck, out tmpMissingMandatorySegments); if ((child.IsMandatory && child.IsIgnore == false) || node != null) { missingMandatorySegments = JoinCSVList(missingMandatorySegments, tmpMissingMandatorySegments); } if (node != null) { return(node); } } return(null); }
/// <summary> /// Construct DocumentFragment from IPluglet for non-leaf elements /// </summary> /// <param name="pluglet"></param> /// <param name="parent"></param> /// <returns></returns> public static DocumentFragment ConstructDocumentFragment(this IPluglet pluglet, IDocumentFragment parent, string value) { if (pluglet == null) { throw new ArgumentNullException("pluglet"); } ++pluglet.CurrentOccurrences; DocumentFragment documentFragment = new DocumentFragment() { Pluglet = pluglet, Parent = parent, Value = value, }; return(documentFragment); }
private static int AddPluglet(ExcelWorksheet ws, IPluglet rootPluglet, ref int row, int level) { ws.Cells[row, NodeTypeIndex].Value = rootPluglet.PlugletType; ws.Cells[row, MandatoryIndex].Value = rootPluglet.IsRecursiveMandatory ? "Y" : "N"; ws.Cells[row, Level1NameIndex + level].Value = rootPluglet.Name; ws.Cells[row, DescriptionIndex].Value = rootPluglet.Definition; ws.Cells[row, PathIndex].Value = rootPluglet.Path; ws.Cells[row, RepeatableIndex].Value = rootPluglet.IsRepeatable ? "Y" : "N"; ws.Cells[row, Level1NameIndex + level].Style.Fill.PatternType = ExcelFillStyle.Solid; ws.Cells[row, Level1NameIndex + level].Style.Fill.BackgroundColor.SetColor(GetColor(rootPluglet.PlugletType)); //ws.Cells[row, 1, row, 4].Style.Font.Bold = true; //Sets the outline depth ws.Row(row).OutlineLevel = level; ws.Row(row).Collapsed = level >= 3; ExcelRange range = ws.Cells[row, PathIndex]; //Console.WriteLine(range.Address + " " + rootPluglet.Path); row++; //Add children foreach (IPluglet attr in rootPluglet.Attributes) { if (level < 7) { //Console.WriteLine("Getting called " + child.Name + " for row " + row + " level " + (level + 1)); AddPluglet(ws, attr, ref row, level + 1, true); } } foreach (IPluglet child in rootPluglet.Children) { if (level < 7) { //Console.WriteLine("Getting called " + child.Name + " for row " + row + " level " + (level + 1)); AddPluglet(ws, child, ref row, level + 1); } } return(row); }
private static void SetMinAndMaxOccurs(IPluglet pluglet, XmlSchemaElement element) { if (pluglet.RepetitionInfo.MinOccurs != 1) { element.MinOccurs = pluglet.RepetitionInfo.MinOccurs; } int maxOccurs = pluglet.RepetitionInfo.MaxOccurs; if (maxOccurs < 0) { element.MaxOccursString = "unbounded"; } else if (maxOccurs != 1) { element.MaxOccursString = maxOccurs.ToString(); } }
private static bool LoopAllowed(IPluglet child) { bool allowLoop = false; int level = 0; while (child.PlugletType == PlugletType.Loop && child.Parent != null) { level++; child = child.Parent; } // +1 for root node (X12) if (level <= (SupportedNestedLevels + 1)) { allowLoop = true; } return(allowLoop); }
public static XElement SerializeToXml(this IPluglet pluglet) { if (pluglet == null) { return(null); } string description = string.IsNullOrEmpty(pluglet.Definition) ? "undef" : pluglet.Definition; string standard = string.IsNullOrEmpty(pluglet.DEStandard) ? "undef" : pluglet.DEStandard; string denumber = string.IsNullOrEmpty(pluglet.DENumber) ? "undef" : pluglet.DENumber; XElement plugletXml = new XElement(pluglet.PlugletType.ToString() , new XAttribute("Tag", pluglet.Tag) , new XAttribute("Name", pluglet.Name) , new XAttribute("Definition", description) , new XAttribute("DENameStandard", standard) , new XAttribute("DENumber", denumber) , new XAttribute("IsMandatory", pluglet.IsMandatory) , new XAttribute("IsIgnore", pluglet.IsIgnore) , new XAttribute("MaxOccur", pluglet.RepetitionInfo.MaxOccurs) , new XAttribute("IsRepeatable", pluglet.IsRepeatable) , new XAttribute("DataType", GetPlugletDataType(pluglet.DataType)) ); if (pluglet.PlugletType != PlugletType.Data && pluglet.PlugletType != PlugletType.Unknown) { plugletXml.Add(new XAttribute("Path", pluglet.Path)); } if (pluglet.Children != null //&& pluglet.PlugletType != PlugletType.Segment ) { foreach (IPluglet child in pluglet.Children) { //if(child.PlugletType != PlugletType.Data && child.PlugletType != PlugletType.Unknown) plugletXml.Add(child.SerializeToXml()); } } return(plugletXml); }
/// <summary> /// Traverse pluglet (schema) tree and construct start segment tree /// for each intermediate node /// Start segment can be any segment till first mandatory segment in childrens. /// If child itself has children the start segment list will contain childrens start /// segment list too. /// </summary> /// <param name="pluglet"></param> public static void InitializeStartSegmentList(this IPluglet pluglet) { if (pluglet == null) { throw new ArgumentNullException("pluglet"); } if (pluglet.PlugletType != PlugletType.Loop || pluglet.Children == null) { return; } bool mandatorySegmentFound = false; pluglet.StartSegmentList = new List <IPluglet>(); foreach (IPluglet child in pluglet.Children) { if (child.PlugletType == PlugletType.Loop) { child.InitializeStartSegmentList(); if (mandatorySegmentFound == false) { pluglet.StartSegmentList.AddRange(child.StartSegmentList); } } else if (child.PlugletType == PlugletType.Segment && mandatorySegmentFound == false) { pluglet.StartSegmentList.Add(child); } mandatorySegmentFound = mandatorySegmentFound || child.IsMandatory; } StringBuilder segmentList = new StringBuilder(); pluglet.StartSegmentList.ForEach(s => segmentList.Append(s.Tag + " ")); LoggerFactory.Logger.Debug("PlugletExtensions.InitializeStartSegmentList", "Start segment list ({0}): {1}" , pluglet.Name, segmentList.ToString()); }
/* * ParseParticle * * This method parses an XML particle. A particle can be one of the following: * * XmlSchemaElement * XmlSchemaGroupBase - can be Sequence, Choice or All. * XmlSchemaGroupRef */ private static IPluglet ParseParticle(IPluglet parent, XmlSchemaParticle pa, XmlSchema schema) { //Console.WriteLine("ParseParticle.. " + pa.Id); IPluglet ret = null; if (pa is XmlSchemaElement) { ret = ParseElement(parent, (XmlSchemaElement)pa, schema); } else if (pa is XmlSchemaAny) { AppendSchemaError("SchemaCode107EXmlSchemaAnyFound"); } else if (pa is XmlSchemaGroupBase) { if (pa is XmlSchemaAll) { AppendSchemaError("SchemaCode108EXmlSchemaAllFound"); } else if (pa is XmlSchemaSequence) { AppendSchemaError("SchemaCode109EXmlSchemaSequenceFound"); } else if (pa is XmlSchemaChoice) { AppendSchemaError("SchemaCode110EXmlSchemaChoiceFound"); } } else if (pa is XmlSchemaGroupRef) { ParseParticle(parent, (XmlSchemaParticle)((XmlSchemaGroupRef)pa).Particle, schema); } return(ret); }
protected override DocumentPlug ConstructDocumentPlug(ExcelWorksheet schemaWorksheet, int startRow) { ReadMetadata(schemaWorksheet); Pluglet rootPluglet = new Pluglet( new PlugletInput() { Name = RootNodeName, Definition = "GC root node", Type = PlugletType.Loop, Parent = null, IsTagSameAsName = true, // for XML spec cert tag is always same as name }); DocumentPlug documentPlug = new DocumentPlug(rootPluglet, BusinessDomain.Xml); // Assumption: Element names are not repeated on teh subsequent lines IPluglet loopPluglet = null; IPluglet nextPluglet; int minOccurs, maxOccurs; int row = startRow; // This loop is for level-1 nodes try { while ((nextPluglet = GetNextNode(schemaWorksheet, 1, ref row)) != null) { rootPluglet.Children.Add(nextPluglet); nextPluglet.Parent = rootPluglet; } } catch (Exception ex) { throw new Exception(string.Format("Row: {0}, Error: {1}", row, ex.Message)); } return(documentPlug); }