/// <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);
}
private static List <EDIValidationResult> ValidateEdi(List <DocumentPlugValidationInfo> documentPlugValidationInfoList)
{
if (documentPlugValidationInfoList == null || documentPlugValidationInfoList.Count <= 1)
{
throw new ArgumentNullException("documentPlugValidationInfoList", "documentPlugValidationInfoList cannot be null and should have > 1 entries");
}
List <EDIValidationResult> ediValidationResults = new List <EDIValidationResult>();
EDIValidationResult ediValidationResult;
foreach (DocumentPlugValidationInfo documentPlugValidationInfo in documentPlugValidationInfoList)
{
if (documentPlugValidationInfo.DocumentPlug == null)
{
TradingPartnerSpecCertMetadata tradingPartnerSpecCertMetadata = new TradingPartnerSpecCertMetadata();
tradingPartnerSpecCertMetadata.Initialize(documentPlugValidationInfo.SpecCertName);
ediValidationResult = new EDIValidationResult();
ediValidationResult.BeautifiedOriginalPayload = EdiValidator.FormatEDIData(documentPlugValidationInfo.FileContents);
ediValidationResult.FileName = tradingPartnerSpecCertMetadata.SchemaFileName;
ediValidationResult.SchemaName = tradingPartnerSpecCertMetadata.SchemaFileName;
ediValidationResult.DisplayName = tradingPartnerSpecCertMetadata.GetCertFileDisplayName();
ediValidationResult.Type = tradingPartnerSpecCertMetadata.Type;
ediValidationResult.SegmentValidationResults = new List <SegmentValidationResult>();
ediValidationResult.SegmentValidationResults.Add(new SegmentValidationResult()
{
Description = tradingPartnerSpecCertMetadata.SchemaFileName + " Spec cert does not exist",
EndIndex = -1,
Name = "N/A",
SequenceNumber = -1,
StartIndex = -1,
Type = ResultType.Error
});
}
else
{
IFatpipeDocument fatpipeDocument;
ediValidationResult = EdiValidator.ValidateEdi(documentPlugValidationInfo.FileContents, documentPlugValidationInfo.FileName,
documentPlugValidationInfo.SpecCertName, documentPlugValidationInfo.DocumentPlug, out fatpipeDocument);
documentPlugValidationInfo.FatpipeDocument = fatpipeDocument;
}
ediValidationResults.Add(ediValidationResult);
}
return(ediValidationResults);
}
/// <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 void LogValidationResult(EDIValidationResult result, StreamWriter logFile)
{
if (result != null && result.SegmentValidationResults != null && result.SegmentValidationResults.Count > 0)
{
bool errors = false;
foreach (SegmentValidationResult segmentValidationResult in result.SegmentValidationResults)
{
if (segmentValidationResult.Type == ResultType.Error)
{
errors = true;
}
string message = string.Format("SequenceNumber: {0}, Name: {1}, StartIndex: {2}, EndIndex: {3}, Description: {4}"
, segmentValidationResult.SequenceNumber, segmentValidationResult.Name, segmentValidationResult.StartIndex
, segmentValidationResult.EndIndex, segmentValidationResult.Description);
if (segmentValidationResult.Type == ResultType.Error)
{
LogError(logFile, message);
}
else
{
LogWarning(logFile, message);
}
}
if (errors)
{
LogError(logFile, "Validation result: Failed");
}
else
{
LogWarning(logFile, "Validation result: Passed with warnings");
}
}
else
{
LogInformation(logFile, "Validation result: Passed");
}
}
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);
}
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);
}
public static void AddUsageEvent(string userName, string homeOrgName, string partnerName, string certFile, EDIValidationResult result,
TimeSpan executionTime, string testFileName, string service, IDalManager dal)
{
string validationStatus = "Success";
if (result != null)
{
if (!result.IsValid)
{
validationStatus = "Error";
}
else
if (result.SegmentValidationResults != null && result.SegmentValidationResults.Count > 0)
{
validationStatus = "Warning";
}
}
List <string> transactionNumbers = result.TransactionNumbers;
if (transactionNumbers == null)
{
transactionNumbers = new List <string>();
}
if (transactionNumbers.Count == 0)
{
transactionNumbers.Add(string.Empty);
}
string instanceFileName;
foreach (string transactionNumber in transactionNumbers)
{
instanceFileName = testFileName;
if (string.IsNullOrWhiteSpace(transactionNumber) == false)
{
instanceFileName += " - " + transactionNumber;
}
AddUsageEvent(userName, homeOrgName, partnerName, certFile, validationStatus, executionTime, instanceFileName, service, dal);
}
}
