public static void ValidateInstanceFile(string btmFileName, string instanceFileName) { string outputDirName = Path.GetFileNameWithoutExtension(btmFileName); if (Directory.Exists(outputDirName) == false) { Directory.CreateDirectory(outputDirName); } string btmFileDirName = Path.GetDirectoryName(btmFileName); ConsoleExtensions.WriteInfo("Reading {0}", Path.GetFileName(btmFileName)); BTMFileInfo btmFileInfo = BTMFileReader.ReadBTMFile(btmFileName); ConsoleExtensions.WriteInfo("\t{0}", btmFileInfo.SourceTree); SpecCertGenerator srcSpecCert = new SpecCertGenerator(btmFileInfo.SourceTree, btmFileDirName, outputDirName); srcSpecCert.Generate(); IDocumentPlug srcDocumentPlug = srcSpecCert.DocumentPlug; ConsoleExtensions.WriteInfo("\t{0}", btmFileInfo.TargetTree); SpecCertGenerator trgSpecCert = new SpecCertGenerator(btmFileInfo.TargetTree, btmFileDirName, outputDirName); trgSpecCert.Generate(); IDocumentPlug trgDocumentPlug = srcSpecCert.DocumentPlug; }
public static IDocumentPlug CreateDocumentPlugFromXmlSchema(string schemaPath) { Stream schemaStream = new FileStream(schemaPath, FileMode.Open, FileAccess.Read); IDocumentPlug plug = XmlSchemaHelper.CreateDocumentPlug(schemaStream); return(plug); }
public static EDIValidationResult ValidateEdi(string ediData, string ediFileName, string certFileFullName, IDocumentPlug documentPlug, out IFatpipeDocument fatpipeDocument) { if (string.IsNullOrWhiteSpace(ediData)) { throw new ArgumentNullException("ediData", "Edi file content cannot be empty"); } if (string.IsNullOrWhiteSpace(certFileFullName)) { throw new ArgumentNullException("certFileFullName", "certFileFullName cannot be empty"); } Stopwatch sw = new Stopwatch(); sw.Start(); TradingPartnerSpecCertMetadata tradingPartnerSpecCertMetadata = new TradingPartnerSpecCertMetadata(); // Purposely ignoring Initialize function return type (errors) since I don't expect errors here. // Spec cert is uploaded only after validation. tradingPartnerSpecCertMetadata.Initialize(certFileFullName, null, DateTime.MinValue); return(ValidateEdi(ediData, ediFileName, tradingPartnerSpecCertMetadata.SchemaFileName, tradingPartnerSpecCertMetadata.GetCertFileDisplayName(), tradingPartnerSpecCertMetadata.Type, (SpecCertFileType)tradingPartnerSpecCertMetadata.FileType, documentPlug, out fatpipeDocument)); }
public static bool SerializeToStream(IDocumentPlug plug, Stream outputStream) { bool result = true; XmlSchema schema = SerializeToXSD(plug); schema.Write(outputStream); return(result); }
public XmlDocument initialize(string xmlContent, IDocumentPlug plug) { XmlDocument doc = new XmlDocument(); doc.LoadXml(xmlContent); this.plug = plug; return(doc); }
private static int AddPluglet(ExcelWorksheet ws, IDocumentPlug plug, ref int row, int level) { foreach (IPluglet child in plug.RootPluglet.Children) { AddPluglet(ws, child, ref row, level); } return(row); }
/// <summary> Wrapper over EDIReader for GC validation feature (Based on spec cert). </summary> /// <param name="ediData">EDI text data (edi file content)</param> /// <param name="ediFileName">This is for record keeping only, not used by EDIReader</param> /// <param name="certFileFullName">Spec cert file (relative path)</param> /// <param name="dalManager">To retrieve schema</param> /// <returns></returns> public static EDIValidationResult ValidateEdi(string ediData, string ediFileName, string certFileFullName, IDalManager dalManager) { if (string.IsNullOrWhiteSpace(ediData)) { throw new ArgumentNullException("ediData", "Edi file content cannot be empty"); } if (string.IsNullOrWhiteSpace(certFileFullName)) { throw new ArgumentNullException("certFileFullName", "certFileFullName cannot be empty"); } if (dalManager == null) { throw new ArgumentNullException("dalManager", "dalManager cannot be null"); } TradingPartnerSpecCertMetadata tradingPartnerSpecCertMetadata = new TradingPartnerSpecCertMetadata(); // Purposely ignoring Initialize function return type (errors) since I don't expect errors here. // Spec cert is uploaded only after validation. tradingPartnerSpecCertMetadata.Initialize(certFileFullName, null, DateTime.MinValue); EDIValidationResult ediValidationResult = new EDIValidationResult() { FileName = ediFileName, SchemaName = tradingPartnerSpecCertMetadata.SchemaFileName, SegmentValidationResults = new List <SegmentValidationResult>(), TransactionNumbers = new List <string>(), DisplayName = tradingPartnerSpecCertMetadata.GetCertFileDisplayName(), Type = tradingPartnerSpecCertMetadata.Type, }; try { IDocumentPlug documentPlug = SchemaCache.GetDocumentPlug(tradingPartnerSpecCertMetadata, dalManager); IFatpipeDocument fatpipeDocument; ediValidationResult = ValidateEdi(ediData, ediFileName, certFileFullName, documentPlug, out fatpipeDocument); } catch (Exception ex) { ediValidationResult.SegmentValidationResults.Add( new SegmentValidationResult() { Type = ResultType.Error, SequenceNumber = -1, Name = "N/A", Description = "Internal error occurred", //ex.Message, StartIndex = -1, EndIndex = -1, } ); } return(ediValidationResult); }
public static IDocumentPlug CreateDocumentPlug(XmlSchemaCollection collection, string targetNamespace, string name) { IDocumentPlug plug = ParseSchema(new XmlQualifiedName(name, targetNamespace), collection[targetNamespace]); if (plug.Error.Count > 0) { throw new Exception("Error encountered in loading schema"); } return(plug); }
/// <summary> /// Construct ITranformPlug based on source and target plug /// </summary> /// <param name="sourcePlug"></param> /// <param name="targetPlug"></param> /// <returns></returns> public static ITransformPlug CreateTransformPlug(IDocumentPlug sourcePlug, IDocumentPlug targetPlug) { //TODO: Implement this - currently hard coded path string path = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..\..\"), @"sources\test\GCommerceSuperSpec\GCommerceSuperSpecInbound850FromBuyer\InboundPO.btm"); FileInfo btmFileInfo = new FileInfo(path); XElement btmRoot = XElement.Load(btmFileInfo.FullName); return(MapperHelper.CreateTransformPlugFromBTM(btmRoot, sourcePlug, targetPlug)); }
private IDocumentPlug CreateEDIDocumentPlug(int currentTransactionSetType, string[] ISARecordFields) { string path, targetNamespace, name; IDocumentPlug documentPlug = null; switch (currentTransactionSetType) { case 850: name = "X12_00401_850"; targetNamespace = @"http://schemas.microsoft.com/BizTalk/EDI/X12/2006"; if (SchemaCache.ContainsKey(name)) { documentPlug = SchemaCache[name]; } break; case 277: name = "X12_005010X214_277B3"; targetNamespace = @"urn:x12:schemas:005:010:277B3:HealthCareInformationStatusNotification"; if (SchemaCache.ContainsKey(name)) { documentPlug = SchemaCache[name]; } break; default: throw new PlugDataModelException(string.Format("{0} schema not found", currentTransactionSetType)); } if (documentPlug == null) { string docType = string.Format("{0}#{1}", targetNamespace, name); Stream schemaStream = FPManager.RetrieveSchema(docType); XmlReader reader = new XmlTextReader(schemaStream); //Stream schemaStream = FatPipeManager.RetrieveSchema(rootNodeName); //XmlReader reader = new XmlTextReader(schemaStream); XmlSchemaCollection schemaCollection = new XmlSchemaCollection(); schemaCollection.Add(targetNamespace, reader); documentPlug = DocumentPlugFactory.CreateDocumentPlugFromXmlSchema(schemaCollection, targetNamespace, name); SchemaCache[name] = documentPlug; } return(documentPlug); }
public static void PrintDocumentPlug(IDocumentPlug plug, string path) { StringBuilder builder = new StringBuilder(10 * 1000); PrintDocumentPlug(plug.RootPluglet, builder, 0); using (System.IO.StreamWriter sw = new System.IO.StreamWriter(path)) { sw.Write("NodeType Mandatory Description TopLevelName Level2Name, Level3Name, Level4Name, Level5Name"); sw.WriteLine(); sw.WriteLine(); sw.Write(builder.ToString()); } Console.WriteLine("Written to " + path); }
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); }
private static void ValidateAndUploadSpecCert(MapDetail mapDetail, SpecCertGenerationResult result, StreamWriter logFile, bool uploadSpecCert, string specCertType) { LogInformation(logFile, string.Format("Generating document plug from spec cert {0}", Path.GetFileName(result.SpecCertPath))); using (StreamReader stream = new StreamReader(result.SpecCertPath)) { try { GCExcelToDocumentPlug excelToDocumentPlug; switch (specCertType) { case "edi": excelToDocumentPlug = new X12GCExcelToDocumentPlug(); break; case "xml": excelToDocumentPlug = new XmlGCExcelToDocumentPlug(); break; case "flatfile": excelToDocumentPlug = new FlatFileGCExcelToDocumentPlug(); break; default: throw new NotSupportedException(string.Format("Spec cert type {0} is not supported", specCertType)); break; } IDocumentPlug plug = excelToDocumentPlug.GenerateDocumentPlug(stream.BaseStream, mapDetail.OrgName, mapDetail.DocumentType, mapDetail.Direction, Maarg.Contracts.GCValidate.SpecCertFileType.X12); // Serialize document plug for investigation plug.SerializeToXml().Save(Path.ChangeExtension(result.SpecCertPath, "xml")); if (uploadSpecCert) { // TODO: Add logic to upload to Azure blob LogWarning(logFile, "Upload functionality will be added soon."); } LogInformation(logFile, string.Format("Document plug generated successfully")); } catch (Exception ex) { result.Errors.Add(string.Format("Spec cert validation failed. Error: {0}", ex.ToString())); LogError(logFile, string.Format("Spec cert validation failed. Error: {0}", ex.ToString())); } } }
public static ITransformPlug CreateTransformPlugFromBTM(XElement btmRoot, IDocumentPlug sourcePlug, IDocumentPlug targetPlug) { string srcName, trgName; srcName = trgName = null; XElement e = GetFirstElement(btmRoot, "SrcTree"); srcName = GetAttributeValue(e, "RootNode_Name"); XElement reference = GetFirstElement(e, "Reference"); string sourceLocation = null; if (reference != null) { sourceLocation = GetAttributeValue(reference, "Location"); } e = GetFirstElement(btmRoot, "TrgTree"); trgName = GetAttributeValue(e, "RootNode_Name"); reference = GetFirstElement(e, "Reference"); string targetLocation = null; if (reference != null) { targetLocation = GetAttributeValue(reference, "Location"); } ITransformPlug plug = new TransformPlug(sourcePlug, targetPlug, null, sourceLocation, targetLocation); IEnumerable <XElement> pageList = btmRoot.Elements(XName.Get("Pages")); IEnumerable <XElement> pages = null; foreach (XElement p in pageList) { pages = p.Elements(XName.Get("Page")); break; } foreach (XElement page in pages) { ITransformGroup group = ParsePage(page); MarkForIgnore(group); plug.Facets.Add(group); } //PrintTransformPlug(plug); return(plug); }
public void SavePartnerSchema(IDocumentPlug documentPlug, string partnerIdentifier) { if (documentPlug == null) { throw new ArgumentNullException("documentPlug"); } if (string.IsNullOrEmpty(partnerIdentifier)) { throw new ArgumentException("To save schema, it must have a valid PartnerIdentifier.", "partnerIdentifier"); } DALSchema dal = new DALSchema(this.storageAccount, this.container, partnerIdentifier); dal.Save(documentPlug as DocumentPlug); }
private void GenerateDocumentPlug(string schema) { if (string.IsNullOrWhiteSpace(schema)) { throw new ArgumentNullException("schema"); } using (Stream schemaStream = GenerateStreamFromString(schema)) { IDocumentPlug documentPlug = DocumentPlugFactory.CreateDocumentPlugFromXmlSchema(schemaStream); XElement schemaXml = documentPlug.SerializeToXml(); schemaXml.Save(Path.Combine(OutputDirName, Path.ChangeExtension(TreeReference, "xml"))); DocumentPlug = documentPlug; } }
/// <summary>Wrapper over EDIReader for GC validation feature (based on Bts assembly file). </summary> /// <param name="ediData">EDI text data (edi file content)</param> /// <param name="ediFileName">This is for record keeping only, not used by EDIReader</param> /// <param name="certFileFullName">Spec cert file (relative path)</param> /// <param name="documentPlug">Document plug</param> /// <returns></returns> public static EDIValidationResult ValidateEdi(string ediData, string ediFileName, string schemaFileName, string certFileDisplayName, string type, SpecCertFileType fileType, IDocumentPlug documentPlug) { if (string.IsNullOrWhiteSpace(ediData)) { throw new ArgumentNullException("ediData", "Edi file content cannot be empty"); } if (documentPlug == null) { throw new ArgumentNullException("documentPlug", "documentPlug cannot be null"); } EDIValidationResult ediValidationResult = new EDIValidationResult() { FileName = ediFileName, SchemaName = schemaFileName, SegmentValidationResults = new List <SegmentValidationResult>(), TransactionNumbers = new List <string>(), DisplayName = certFileDisplayName, Type = type, }; try { IFatpipeDocument fatpipeDocument; ediValidationResult = ValidateEdi(ediData, ediFileName, schemaFileName, certFileDisplayName, type, fileType, documentPlug, out fatpipeDocument); } catch (Exception ex) { ediValidationResult.SegmentValidationResults.Add( new SegmentValidationResult() { Type = ResultType.Error, SequenceNumber = -1, Name = "N/A", Description = "Internal error occurred", //ex.Message, StartIndex = -1, EndIndex = -1, } ); } return(ediValidationResult); }
private static Delimiters InitializeDelimiters(IDocumentPlug documentPlug) { int componentSeparator = 0; // Flat file does not have have components int segmentDelimiterSuffix1 = 0; int segmentDelimiterSuffix2 = 0; if (documentPlug.SegmentDelimiters.Count > 1) { segmentDelimiterSuffix1 = documentPlug.SegmentDelimiters[1]; } if (documentPlug.SegmentDelimiters.Count > 2) { segmentDelimiterSuffix2 = documentPlug.SegmentDelimiters[2]; } return(new Delimiters(documentPlug.ElementDelimiters[0], componentSeparator, documentPlug.SegmentDelimiters[0], segmentDelimiterSuffix1, segmentDelimiterSuffix2)); }
/// <summary> /// This function should be used only for unit testing where we don't want to connect to Azure storage /// </summary> /// <param name="currentTransactionSetType"></param> /// <returns></returns> public static IDocumentPlug CreateEDIDocumentPlug(int currentTransactionSetType) { string path, targetNamespace, name; switch (currentTransactionSetType) { case 820: path = "820-R1.xsd"; targetNamespace = @"urn:x12:schemas:005010X306:820R1:HealthInsuranceExchangeRelatedPayments"; name = "X12_005010X306_820R1"; break; case 850: path = "GCommerce.EDI._00401._850.Schemas.Enriched_X12_00401_850"; targetNamespace = @"http://schemas.microsoft.com/BizTalk/EDI/EDIFACT/2006/EnrichedMessageXML"; name = "X12EnrichedMessage"; break; case 277: path = "X12_005010X214_277B3.xsd"; targetNamespace = @"urn:x12:schemas:005:010:277B3:HealthCareInformationStatusNotification"; name = "X12_005010X214_277B3"; break; case 810: path = "X12_00501_810.xsd"; targetNamespace = @"http://schemas.microsoft.com/BizTalk/EDI/X12/2006"; name = "X12_00501_810"; break; default: throw new Exception(string.Format("{0} schema not found", currentTransactionSetType)); } IDocumentPlug schemaPlug = DocumentPlugFactory.CreateDocumentPlugFromXmlSchema(path, targetNamespace, name); XElement schemaXml = schemaPlug.SerializeToXml(); schemaXml.Save(string.Format("Schema_{0}.xml", currentTransactionSetType)); return(schemaPlug); }
public static void GenerateExcelFromDocumentPlug(string outputFilePath, IDocumentPlug plug) { Console.WriteLine("Generating plug in " + outputFilePath); FileInfo newFile = new FileInfo(outputFilePath); if (newFile.Exists) { newFile.Delete(); // ensures we create a new workbook newFile = new FileInfo(outputFilePath); } //Create the workbook ExcelPackage pck = new ExcelPackage(newFile); GenerateWorksheetFromDocumentPlug(pck.Workbook, plug, 1, false); //Done! save the sheet pck.Save(); Console.WriteLine("Plug written to " + outputFilePath); }
public static XElement SerializeToXml(this IDocumentPlug documentPlug) { if (documentPlug == null) { return(null); } string name = string.IsNullOrEmpty(documentPlug.Name) ? "undef" : documentPlug.Name; string elementDelimiter = GetDelimiterString(documentPlug.ElementDelimiters); string segmentDelimiter = GetDelimiterString(documentPlug.SegmentDelimiters); XElement plugletXml = new XElement("DocumentPlug" , new XAttribute("Name", name) , new XAttribute("ElementDelimiter", elementDelimiter) , new XAttribute("SegmentDelimiter", segmentDelimiter) ); plugletXml.Add(documentPlug.RootPluglet.SerializeToXml()); return(plugletXml); }
/// <summary> /// Merge documentPlug with newDocumentPlug and return mergedDocumentPlug. /// canonicalDocumentPlug is used to decide children order during merge process /// </summary> /// <param name="documentPlug"></param> /// <param name="newDocumentPlug"></param> /// <param name="canonicalDocumentPlug"></param> /// <returns></returns> public static IDocumentPlug Merge(IDocumentPlug documentPlug, IDocumentPlug newDocumentPlug, IDocumentPlug canonicalDocumentPlug) { if (documentPlug == null) { throw new ArgumentNullException("documentPlug"); } if (newDocumentPlug == null) { throw new ArgumentNullException("newDocumentPlug"); } if (canonicalDocumentPlug == null) { throw new ArgumentNullException("canonicalDocumentPlug"); } DocumentPlug mergedDocumentPlug = new DocumentPlug(null, documentPlug.BusinessDomain); mergedDocumentPlug.RootPluglet = documentPlug.RootPluglet.Merge(newDocumentPlug.RootPluglet, canonicalDocumentPlug.RootPluglet); return(mergedDocumentPlug); }
public static IDocumentPlug GetDocumentPlug(TradingPartnerSpecCertMetadata tradingPartnerSpecCertMetadata, IDalManager dalManager) { IDocumentPlug documentPlug = gcSpecCertCache.GetObject(tradingPartnerSpecCertMetadata.SchemaFileName) as IDocumentPlug; if (documentPlug == null) { Stream schemaStream = dalManager.GetTradingPartnerSpecCert(tradingPartnerSpecCertMetadata); if (schemaStream == null) { throw new GCEdiValidatorException(string.Format("{0} Schema not found.", tradingPartnerSpecCertMetadata.SchemaFileName)); } GCExcelToDocumentPlug gcExcelToDocumentPlug = GCExcelToDocumentPlug.CreateInstance((SpecCertFileType)tradingPartnerSpecCertMetadata.FileType); documentPlug = gcExcelToDocumentPlug.GenerateDocumentPlug(schemaStream, tradingPartnerSpecCertMetadata.TradingPartnerName, tradingPartnerSpecCertMetadata.DocumentType, tradingPartnerSpecCertMetadata.Direction, (SpecCertFileType)tradingPartnerSpecCertMetadata.FileType); gcSpecCertCache.AddObject(tradingPartnerSpecCertMetadata.SchemaFileName, documentPlug); } return(documentPlug); }
public static void GenerateWorksheetFromDocumentPlug(ExcelWorkbook workBook, IDocumentPlug plug, int startRow, bool usingTemplate) { ExcelWorksheet ws; if (usingTemplate) { ws = workBook.Worksheets[1]; } else { //Add the Content sheet string name = plug.Name; ws = workBook.Worksheets.Add(name); } ws.View.ShowGridLines = true; ws.OutLineSummaryRight = true; int row = startRow; int lastRow = AddPluglet(ws, plug, ref row, 0); ws.OutLineSummaryBelow = false; }
public static IPluglet extractPluglet(IPluglet root, XmlNode node, IDocumentPlug plug) { string result = retreiveFullName(node); string[] nodeNames = result.Split('/'); IPluglet current = root; if (current.Name.Equals(nodeNames[0])) { for (int i = 1; i < nodeNames.Length; i++) { current = findPlugletByName(current.Children, nodeNames[i]); if (current == null) { plug.Error.Add("Could not find Element " + nodeNames[i]); } } } else { plug.Error.Add("Root Element does not match"); } return(current); }
private static int ValidateInstanceFile(Parameters parameters) { string specCertFullPath = parameters.SpecCertName; string specCertFileName = Path.GetFileName(specCertFullPath); string instanceFilePath = parameters.InstanceFileName; string instanceFileName = Path.GetFileName(instanceFilePath); if (File.Exists(specCertFullPath) == false) { ConsoleExtensions.WriteError("{0} does not exist.", specCertFullPath); return(1); } if (Path.GetExtension(specCertFullPath) != ".xlsx") { ConsoleExtensions.WriteError("{0} is not a zip file.", specCertFullPath); return(1); } if (File.Exists(instanceFilePath) == false) { ConsoleExtensions.WriteError("{0} does not exist.", instanceFilePath); return(1); } string logFileName = Path.ChangeExtension(instanceFileName, "log"); ConsoleExtensions.WriteInfo("Log file for this processing: {0}", logFileName); string instanceFileData = File.ReadAllText(instanceFilePath); using (StreamWriter logFile = new StreamWriter(logFileName)) { try { TradingPartnerSpecCertMetadata metadata = new TradingPartnerSpecCertMetadata(); metadata.Initialize(specCertFileName); GCExcelToDocumentPlug excelToDocumentPlug; switch ((SpecCertFileType)metadata.FileType) { case SpecCertFileType.X12: excelToDocumentPlug = new X12GCExcelToDocumentPlug(); break; case SpecCertFileType.Xml: excelToDocumentPlug = new XmlGCExcelToDocumentPlug(); break; case SpecCertFileType.FlatFile: excelToDocumentPlug = new FlatFileGCExcelToDocumentPlug(); break; default: throw new NotSupportedException(string.Format("Spec cert type {0} is not supported", (SpecCertFileType)metadata.FileType)); break; } LogInformation(logFile, string.Format("Generating document plug from spec cert {0}", specCertFileName)); TradingPartnerSpecCertMetadata specCertMetadata = new TradingPartnerSpecCertMetadata(); specCertMetadata.Initialize(specCertFileName); IDocumentPlug documentPlug = null; using (StreamReader stream = new StreamReader(specCertFullPath)) documentPlug = excelToDocumentPlug.GenerateDocumentPlug( stream.BaseStream, specCertMetadata.TradingPartnerName, specCertMetadata.DocumentType, specCertMetadata.Direction, Maarg.Contracts.GCValidate.SpecCertFileType.X12); if (documentPlug == null) { LogError(logFile, "Document plug generation failed"); return(-1); } else { LogInformation(logFile, "Document plug generated successfully"); } LogInformation(logFile, "Validating instance file"); IFatpipeDocument fatpipeDocument; EDIValidationResult result = EdiValidator.ValidateEdi(instanceFileData, instanceFileName, specCertFileName, documentPlug, out fatpipeDocument); LogValidationResult(result, logFile); } catch (Exception ex) { LogError(logFile, string.Format("Error encountered during validating {0} file. Error: {1}", instanceFileName, ex.ToString())); } } return(0); }
/// <summary> /// Create plug based on the fatpipeDocument (instance tree). /// Generated plug will only have pluglets referred in instance tree. /// Generated plug will have repeated pluglets in case of loops. /// </summary> /// <param name="fatpipeDocument"></param> /// <param name="existingDocumentPluglet"></param> /// <returns></returns> public static IDocumentPlug GenerateDocumentPlug(this IFatpipeDocument fatpipeDocument, IDocumentPlug existingDocumentPluglet) { if (fatpipeDocument == null) { throw new ArgumentNullException("fatpipeDocument", "Cannot generate document plug for null IFatpipeDocument"); } DocumentPlug documentPlug = new DocumentPlug(null, fatpipeDocument.DocumentPlug.BusinessDomain); documentPlug.RootPluglet = fatpipeDocument.RootFragment.GeneratePluglet(); documentPlug.RootPluglet = documentPlug.RootPluglet.RemoveLoops(fatpipeDocument.RootFragment.Pluglet); if (existingDocumentPluglet != null) { documentPlug.RootPluglet = documentPlug.RootPluglet.Merge(existingDocumentPluglet.RootPluglet, fatpipeDocument.RootFragment.Pluglet); } documentPlug.RootPluglet.SetParent(null); return(documentPlug); }
/// <summary> /// Initialize EDIReader with a stream. Verify that stream contains EDI document (ISA segment). /// </summary> /// <param name="stream"></param> /// <param name="fatpipeManager"></param> /// <param name="documentPlug"></param> /// <returns>true if EDI document otherwise false</returns> public bool Initialize(Stream stream, IFatpipeManager fatpipeManager, IDocumentPlug documentPlug) { if (stream == null) { throw new ArgumentNullException("stream"); } Stopwatch sw = new Stopwatch(); sw.Start(); Errors = new InterchangeErrors(); FPManager = fatpipeManager; DocumentPlug = documentPlug; long orgStartPos = stream.Position; Delimiters delimiters; InterchangeTokenizer tokenizer = new InterchangeTokenizer(stream); bool isValidEDIDocument = tokenizer.IsX12Interchange(out delimiters); FunctionalGroupNumber = TransactionSetNumber = SegmentNumberFromStart = SegmentNumber = 0; ValidTransactionSetCount = InvalidTransactionSetCount = 0; PrevTransactionSetType = 0; DocumentReader = null; if (isValidEDIDocument == true) { EDIDelimiters = delimiters; //TODO: Review following logic //Read ISA field till component separator - Do not include component separator ISASegment = tokenizer.ISARecord.Substring(0, tokenizer.ISARecord.IndexOf((char)EDIDelimiters.ComponentSeperator) + 1); //TODO: Suraj: confirm this special case - last value as data element separator ISARecordFields = ISASegment.Split((char)EDIDelimiters.FieldSeperator); SegmentNumberFromStart = 1; stream.Position = orgStartPos; this.DocumentReader = new StreamReader(stream, Encoding.UTF8); //TODO: Why is seek required here? this.CurrentSegmentStartPos = 0; this.CurrentSegmentEndPos = 0; //this.CurrentSegmentEndPos = this.CurrentSegmentStartPos + tokenizer.ISARecordLen - 1; //this.DocumentReader.BaseStream.Seek(this.CurrentSegmentEndPos + basePosition, SeekOrigin.Begin); FatpipeDocumentInst = new FatpipeDocument(); FatpipeDocumentInst.BeautifiedOriginalPayloadStartHeader = string.Empty; FatpipeDocumentInst.BeautifiedOriginalPayloadBody = string.Empty; FatpipeDocumentInst.BeautifiedOriginalPayloadEndHeader = string.Empty; SegmentDelimiter = ((char)EDIDelimiters.SegmentDelimiter).ToString(); FormattedSegmentDelimiter = SegmentDelimiter; bool crLFPresent = delimiters.SegmentDelimiter == Delimiters.CarriageReturn || delimiters.SegmentDelimiterSuffix1 == Delimiters.CarriageReturn; if (!crLFPresent) { FormattedSegmentDelimiter = string.Format("{0}{1}", FormattedSegmentDelimiter, Environment.NewLine); } Logger.Info("EDIReader.Initialize", "EDIDelimiters: SegmentDelimiter={0}, FieldSeperator={1}, ComponentSeperator={2}", (char)EDIDelimiters.SegmentDelimiter, (char)EDIDelimiters.FieldSeperator, (char)EDIDelimiters.ComponentSeperator); } else //invalid document code path { this.CurrentSegmentStartPos = orgStartPos; this.CurrentSegmentEndPos = orgStartPos + 3; Logger.Error("EDIReader.Initialize", EventId.EDIReaderInvalidDocument, "EDI document is not valid. Error: {0}", tokenizer.Error); Errors.AddGenericError("ISA", SchemaErrorCode.SchemaCode100EInvalidDocType, tokenizer.Error, SegmentNumber, this.CurrentSegmentStartPos, this.CurrentSegmentEndPos); StringBuilder sb = new StringBuilder(); int errorIndex = 1; Errors.IsaIeaErrorList.WriteError(sb, ref errorIndex); ISASegment = string.Empty; } LastState = EDIState.ISA; sw.Stop(); Logger.Debug("EDIReader.Initialize", "Elapsed time {0} ms", sw.ElapsedMilliseconds); return(isValidEDIDocument); }
public static EDIValidationResult ValidateEdi(string ediData, string ediFileName, string schemaFileName, string certFileDisplayName, string type, SpecCertFileType fileType, IDocumentPlug documentPlug, out IFatpipeDocument fatpipeDocument) { Stopwatch sw = new Stopwatch(); sw.Start(); EDIValidationResult ediValidationResult = new EDIValidationResult() { FileName = ediFileName, SchemaName = schemaFileName, SegmentValidationResults = new List <SegmentValidationResult>(), TransactionNumbers = new List <string>(), DisplayName = certFileDisplayName, Type = type, }; fatpipeDocument = null; try { ediValidationResult.SegmentValidationResults.Clear(); string endHeader = string.Empty; switch (fileType) { case SpecCertFileType.X12: EDIReader ediReader = new EDIReader(); if (ediReader.Initialize(new MemoryStream(Encoding.UTF8.GetBytes(ediData)), null, documentPlug) == true) { try { IFatpipeDocument currentFatpipeDocument = null; while ((currentFatpipeDocument = ediReader.GetNextTransactionSet()) != null) { if (string.IsNullOrWhiteSpace(ediValidationResult.BeautifiedOriginalPayload)) { ediValidationResult.BeautifiedOriginalPayload = currentFatpipeDocument.BeautifiedOriginalPayloadStartHeader; endHeader = currentFatpipeDocument.BeautifiedOriginalPayloadEndHeader; } ediValidationResult.BeautifiedOriginalPayload += currentFatpipeDocument.BeautifiedOriginalPayloadBody; ediValidationResult.TransactionNumbers.Add(currentFatpipeDocument.TransactionNumber); ediValidationResult.SegmentValidationResults.AddRange(ediReader.Errors.GetSegmentValidationResults()); fatpipeDocument = currentFatpipeDocument; } ediValidationResult.BeautifiedOriginalPayload += endHeader; } catch (EDIReaderException ediReaderException) { // Add whatever errors we accumulated ediValidationResult.SegmentValidationResults.AddRange(ediReader.Errors.GetSegmentValidationResults()); ediValidationResult.SegmentValidationResults.Add( new SegmentValidationResult() { Type = ResultType.Error, SequenceNumber = -1, Name = "N/A", Description = ediReaderException.Message, StartIndex = -1, EndIndex = -1, }); } } //ediValidationResult.SegmentValidationResults.AddRange(ediReader.Errors.GetSegmentValidationResults()); break; case SpecCertFileType.FlatFile: FlatFileReader flatFileReader = new FlatFileReader(); fatpipeDocument = flatFileReader.ReadFile(new MemoryStream(Encoding.UTF8.GetBytes(ediData)), documentPlug); ediValidationResult.BeautifiedOriginalPayload = fatpipeDocument.BeautifiedOriginalPayloadBody; ediValidationResult.SegmentValidationResults.AddRange(flatFileReader.Errors.GetSegmentValidationResults()); break; case SpecCertFileType.Xml: XmlFileReader xmlFileReader = new XmlFileReader(); fatpipeDocument = xmlFileReader.ReadFile(new MemoryStream(Encoding.UTF8.GetBytes(ediData)), documentPlug); ediValidationResult.BeautifiedOriginalPayload = fatpipeDocument.BeautifiedOriginalPayloadBody; ediValidationResult.SegmentValidationResults.AddRange(xmlFileReader.Errors.GetSegmentValidationResults()); break; default: ediValidationResult.SegmentValidationResults.Add( new SegmentValidationResult() { Type = ResultType.Error, SequenceNumber = -1, Name = "N/A", Description = "Invalid cert file type (only EDI and FaltFile is supported)", //ex.Message, StartIndex = -1, EndIndex = -1, }); break; } } catch (Exception ex) { ediValidationResult.SegmentValidationResults.Add( new SegmentValidationResult() { Type = ResultType.Error, SequenceNumber = -1, Name = "N/A", //Description = "Internal error occurred",//ex.Message, Description = "Internal error occurred. " + ex.ToString(), StartIndex = -1, EndIndex = -1, }); } sw.Stop(); ediValidationResult.ExecutionTime = sw.Elapsed; return(ediValidationResult); }
/// <summary> /// Read xml file and construct IFatpipeDocument. /// Xml file reader will traverse Xml files and for each element /// match it with current pluglet. If match fails then it tries to /// find matching pluglet (similar to X12). /// </summary> /// <returns></returns> public IFatpipeDocument ReadFile(Stream xmlFileStream, IDocumentPlug documentPlug) { if (xmlFileStream == null) { throw new ArgumentNullException("xmlFileStream", "Xml file stream cannot be null"); } if (documentPlug == null) { throw new ArgumentNullException("documentPlug", "Document plug cannot be null"); } string location = "XmlFileReader.ReadFile"; Logger.Debug(location, "Start"); BeautifiedOriginalPayload = string.Empty; CurrentElementNumber = 0; TotalPayloadLength = 0; CurrentLinePayloadStart = 0; CurrentLinePayloadEnd = 0; CurrentLevel = 0; Stopwatch sw = new Stopwatch(); sw.Start(); errors = new InterchangeErrors(); // Since xml file doesn't have concept of ST/SE, ans we want to use InterchangeErrors for reporting purpose // create dummy transaction set details Errors.AddTransactionSetDetails(1, "", "", true); IPluglet currentPluglet = documentPlug.RootPluglet; currentPluglet.ResetCurrentOccurances(); currentPluglet.InitializeStartSegmentList(); FatpipeDocumentInst = new FatpipeDocument(); FatpipeDocumentInst.DocumentPlug = documentPlug; FatpipeDocumentInst.RootFragment = currentPluglet.ConstructDocumentFragment(null, null); IDocumentFragment currentDocumentFragment = FatpipeDocumentInst.RootFragment; IDocumentFragment newDocumentFragment = null; bool isLeafNode = false; try { XmlTextReader xmlReader = new XmlTextReader(xmlFileStream); // If some element doesn't match document plutlet then stop // TODO: Should we try to match other elements? If yes, which pluglet to start with? // Also we need to ignore this entire element bool stopProcessing = false; while (xmlReader.Read()) { switch (xmlReader.NodeType) { case XmlNodeType.Element: isLeafNode = false; AddStartElementToPayload(xmlReader.Name, xmlReader.IsEmptyElement); if (xmlReader.IsEmptyElement) { break; } if (stopProcessing == false) { currentDocumentFragment = ConstructNewDocumentFragment(xmlReader.Name, currentPluglet, currentDocumentFragment); } // If some element doesn't match document plutlet then stop // TODO: Should we try to match other elements? If yes, which pluglet to start with? // Also we need to ignore this entire element if (currentDocumentFragment == null) { stopProcessing = true; } else { currentPluglet = currentDocumentFragment.Pluglet; } CurrentLevel++; CurrentElementNumber++; break; case XmlNodeType.Text: isLeafNode = true; AddValueToPayload(xmlReader.Value); if (stopProcessing == false) { currentDocumentFragment.Value = xmlReader.Value; } // Assumption: Leaf nodes are on same line and non-leaf nodes are 1-per line (separate line for start and end element) // If this assumption is wrong then we can construct the xml in string format to match fulfill above assumption // and then Ux can use this string version of xml to highlight the errors. CurrentElementNumber--; // Decrement since leaf level elements are one line, so we need to increment element on endElement only. break; case XmlNodeType.EndElement: CurrentLevel--; AddEndElementToPayload(xmlReader.Name, isLeafNode); if (stopProcessing == false) { // Check if all mandatory segments were present CheckMissingMandatoryElements(currentPluglet, currentDocumentFragment); currentDocumentFragment = currentDocumentFragment.Parent; currentPluglet = currentPluglet.Parent; } CurrentElementNumber++; isLeafNode = false; break; default: break; } } } catch (XmlException xmlException) { // TODO: Pass start and end postition Errors.AddGenericError(currentPluglet == null ? "N/A" : currentPluglet.Name, X12ErrorCode.UnexpectedSegmentCode, string.Format("Error parsing XML document: {0}", xmlException.Message), CurrentElementNumber / 2, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength); } catch (Exception exception) { // TODO: Pass start and end postition (for all Errors.Add* calls) in this file. Errors.AddGenericError(currentPluglet == null ? "N/A" : currentPluglet.Name, X12ErrorCode.UnexpectedSegmentCode, "Internal error occurred, please contact Maarg", CurrentElementNumber / 2, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength); Logger.Error(location, EventId.XmlReaderUnhandledException, "Error occured during xml file processing: {0}", exception.ToString()); } FatpipeDocumentInst.BeautifiedOriginalPayloadBody = BeautifiedOriginalPayload; sw.Stop(); Logger.Debug(location, "Stop - Elapsed time {0} ms", sw.ElapsedMilliseconds); return(FatpipeDocumentInst); }