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);
}
