public void Serialize(string filePath)
{
_hd.Header.SenderAddress = _senderAddresses.ToArray();
_hd.Header.Property = _properties.ToArray();
_hd.Payload = _payloads.ToArray();
_serializationHelper.Serialize(_hd, filePath);
}
public void Serialize(string filePath)
{
_hd.Header.Notification = _notifs.ToArray();
_hd.Header.Property = _properties.ToArray();
_hd.Payload = _payloads.ToArray();
_serializationHelper.Serialize(_hd, filePath);
}
private void ProcessEntry(InterceptionProcessingData data, List <RecordingMethod> methods, Guid executingMethodId, int threadId)
{
Guid newMethodId = Guid.NewGuid();
//add this as a method
if (!HasSerializationErrors(data))
{
var serInstance = _serializationHelper.Serialize(data.TargetInstance);
if (!serInstance.Success)
{
throw new AutoTestEngineException($"Unable to serialize type {data.TargetInstance.ToString()} despite not having a serialization failure on the processing datat context");
}
var newMethod = new RecordingMethod(newMethodId, serInstance.SerializedValue, data.MethodArgs, data.Method);
methods.Add(newMethod);
}
//add this as a sub-method if applicable
var executingMethod = methods.FirstOrDefault(x => x.Identifier == executingMethodId);
if (executingMethod != null)
{
var subMethod = new RecordedSubMethod(newMethodId, data.TargetType, data.MethodArgs, data.ReturnType, data.Method);
executingMethod.SubMethods.Add(subMethod);
}
_executionStack.ProcessEntry(threadId, newMethodId);
}
internal string Execute(DateTime changeDate, string targetXmlPath, ISerializationHelper serializationHelper,
ICompressionHelper compressionHelper, HEREBaseService hereBaseService)
{
hereBaseService.AppendAuditLogEvent("Getting data.");
CAFO ds = _dbService.GetCAFOAddData(changeDate);
hereBaseService.AppendAuditLogEvent("Data retrieved. (Record Count = {0}).", ds.CAFO_FAC.Rows.Count);
hereBaseService.AppendAuditLogEvent("Transforming results.");
CAFOFacilityList facs = CAFOTransform.Transform(ds);
if (facs == null || facs.CAFOFacilities == null || facs.CAFOFacilities.Count == 0)
{
return(null);
}
else
{
hereBaseService.AppendAuditLogEvent("Results transformed: (Record Count: {0})", facs.CAFOFacilities.Count);
hereBaseService.AppendAuditLogEvent(
"Serializing transformed results to file (File = {0}).",
targetXmlPath);
serializationHelper.Serialize(facs, targetXmlPath);
return(compressionHelper.CompressFile(targetXmlPath));
}
}
protected virtual void AttachSubmissionResponseToTransaction(string transactionId)
{
string tempXmlFilePath = _settingsProvider.NewTempFilePath();
string tempZipFilePath = _settingsProvider.NewTempFilePath();
try
{
Windsor.Node2008.WNOSPlugin.ICISAIR_54.SubmissionResponseDataType response =
new Windsor.Node2008.WNOSPlugin.ICISAIR_54.SubmissionResponseDataType();
response.CreationDate = response.SubmissionDate = DateTime.Now;
response.TransactionIdentifier = transactionId;
_serializationHelper.Serialize(response, tempXmlFilePath);
string zipDocumentName = string.Format("{0}_Response.xml", transactionId);
string transactionDocumentName = Path.ChangeExtension(zipDocumentName, ".zip");
_compressionHelper.CompressFile(tempXmlFilePath, zipDocumentName, tempZipFilePath);
var document =
new Windsor.Node2008.WNOSDomain.Document(transactionDocumentName, CommonContentType.ZIP,
File.ReadAllBytes(tempZipFilePath));
_documentManager.AddDocument(transactionId, CommonTransactionStatusCode.Completed, null, document);
}
catch (Exception e)
{
AppendAuditLogEvent("Failed to add response file to transaction \"{0}\" with error: {1}",
transactionId, ExceptionUtils.GetDeepExceptionMessage(e));
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
}
}
public List <VerificationFailure> Verify(InterceptionProcessingData processingData)
{
var returnVal = new List <VerificationFailure>();
if (processingData.BoundaryType != BoundaryType.Exit)
{
return(returnVal);
}
if (_helper.IsUnserializable(processingData.ReturnType))
{
returnVal.Add(new TypeSerializationFailure(processingData.ReturnType));
}
else
{
var res = _serializer.Serialize(processingData.ReturnValue);
if (!res.Success)
{
_helper.AddUnserializableType(processingData.ReturnType);
returnVal.Add(new TypeSerializationFailure(processingData.ReturnType));
}
}
return(returnVal);
}
public PaginatedContentResult ProcessQuery(string requestId)
{
GetServiceImplementation(out _requestManager);
GetServiceImplementation(out _serializationHelper);
GetServiceImplementation(out _documentManager);
GetServiceImplementation(out _accountManager);
GetServiceImplementation(out _flowManager);
AppendAuditLogEvent("Validating requestId ...");
DataRequest dataRequest = _requestManager.GetDataRequest(requestId);
GetAuthorizedUsersResponse response = GetAuthorizedUsersResponseData();
byte[] content = _serializationHelper.Serialize(response);
if (response.AuthorizedUserList.Length == 0)
{
AppendAuditLogEvent("Did not find authorization information for any users");
}
else
{
AppendAuditLogEvent("Returning authorization information for {0} users ...", response.AuthorizedUserList.Length);
}
string docId =
_documentManager.AddDocument(dataRequest.TransactionId, CommonTransactionStatusCode.Completed,
null, new Document(null, CommonContentType.XML, content));
PaginatedContentResult result = new PaginatedContentResult(0, response.AuthorizedUserList.Length, true,
CommonContentType.XML, content);
return(result);
}
public List <VerificationFailure> Verify(InterceptionProcessingData processingData)
{
var returnVal = new List <VerificationFailure>();
var instanceType = processingData.TargetInstance.GetType();
if (processingData.BoundaryType != BoundaryType.Entry)
{
return(returnVal);
}
if (_helper.IsUnserializable(instanceType))
{
returnVal.Add(new TypeSerializationFailure(instanceType));
}
else
{
var serResult = _serializer.Serialize(processingData.TargetInstance);
if (!serResult.Success)
{
_helper.AddUnserializableType(instanceType);
returnVal.Add(new TypeSerializationFailure(instanceType));
}
}
return(returnVal);
}
internal string Execute(DateTime changeDate, string targetXmlPath, ISerializationHelper serializationHelper,
ICompressionHelper compressionHelper, HEREBaseService hereBaseService)
{
hereBaseService.AppendAuditLogEvent("Getting data.");
HERE10.DomainDataSet ds = _dbService.GetDomainData(changeDate);
hereBaseService.AppendAuditLogEvent("Data retrieved. (List Count = {0}).", ds.List.Rows.Count);
hereBaseService.AppendAuditLogEvent("Transforming results.");
List <HERE10.DomainList> lists = new List <HERE10.DomainList>();
foreach (HERE10.DomainDataSet.ListRow listRow in ds.List.Rows)
{
HERE10.DomainList item = new HERE10.DomainList();
item.DomainListNameText = listRow.ListName;
item.OriginatingPartnerName = listRow.ListOwnerName;
List <DomainValueItemDataType> listItems = new List <DomainValueItemDataType>();
foreach (HERE10.DomainDataSet.ListItemRow listItemRow in listRow.GetListItemRows())
{
DomainValueItemDataType listItem = new DomainValueItemDataType();
listItem.ItemCode = listItemRow.ItemCode;
listItem.ItemText = listItemRow.ItemValue;
listItem.ItemDescriptionText = listItemRow.ItemDesc;
listItems.Add(listItem);
}
item.DomainListItem = listItems.ToArray();
lists.Add(item);
}
if (lists.Count == 0)
{
return(null);
}
else
{
HERE10.DomainValueListDataType domain = new HERE10.DomainValueListDataType();
domain.DomainList = lists.ToArray();
hereBaseService.AppendAuditLogEvent("Results transformed.");
hereBaseService.AppendAuditLogEvent(
"Serializing transformed results to file (File = {0}).",
targetXmlPath);
serializationHelper.Serialize(domain, targetXmlPath);
return(compressionHelper.CompressFile(targetXmlPath));
}
}
protected string CreateSubmissionFile(Organization data)
{
string tempZipFilePath = _settingsProvider.NewTempFilePath(".zip");
string tempXmlFilePath = _settingsProvider.NewTempFilePath(".xml");
try
{
var content = new ATTAINSDataType()
{
Organization = new Organization[] { data }
};
AppendAuditLogEvent("Serializing data to an xml file");
_serializationHelper.Serialize(content, tempXmlFilePath);
if (_validateXml)
{
ValidateXmlFileAndAttachErrorsAndFileToTransaction(tempXmlFilePath, "xml_schema.xml_schema.zip",
null, _dataRequest.TransactionId);
}
AppendAuditLogEvent("Generating submission file (with an exchange header) from results");
IHeaderDocument2Helper headerDocumentHelper;
GetServiceImplementation(out headerDocumentHelper);
// Configure the submission exchange header and add header to xml file
headerDocumentHelper.Configure(_authorName, _organizationName, _documentTitle, FLOW_NAME,
null, _senderContact, null, null);
headerDocumentHelper.AddNotification(_senderAddress);
string tempXmlFilePath2 = _settingsProvider.NewTempFilePath(".xml");
try
{
XmlDocument doc = new XmlDocument();
doc.Load(tempXmlFilePath);
headerDocumentHelper.AddPayload(_payloadOperation, doc.DocumentElement);
headerDocumentHelper.Serialize(tempXmlFilePath2);
_compressionHelper.CompressFile(tempXmlFilePath2, tempZipFilePath);
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath2);
}
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempZipFilePath);
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
}
return(tempZipFilePath);
}
protected string MakeHeaderFile(object dataObject)
{
AppendAuditLogEvent("Generating header file from results");
// Configure the submission header helper
_headerDocumentHelper.Configure(_author, _organization, _title, null, _contactInfo, null);
_headerDocumentHelper.AddPropery("RCRAInfoStateCode", _rcraInfoStateCode);
_headerDocumentHelper.AddPropery("RCRAInfoUserID", _rcraInfoUserId);
if (!string.IsNullOrEmpty(_notifications))
{
_headerDocumentHelper.AddPropery("NotificationURI", _notifications);
_headerDocumentHelper.AddNotifications(_notifications);
}
string tempXmlFilePath = _settingsProvider.NewTempFilePath();
tempXmlFilePath = Path.ChangeExtension(tempXmlFilePath, ".xml");
AppendAuditLogEvent("Temp file before header:" + tempXmlFilePath);
string tempXmlFilePath2 = _settingsProvider.NewTempFilePath();
tempXmlFilePath2 = Path.ChangeExtension(tempXmlFilePath, ".xml");
AppendAuditLogEvent("Temp file after header:" + tempXmlFilePath2);
_serializationHelper.Serialize(dataObject, tempXmlFilePath);
AppendAuditLogEvent("Temp file serialized");
if (!File.Exists(tempXmlFilePath))
{
throw new IOException("Temp file does not exist: " + tempXmlFilePath);
}
if (_validateXml)
{
ValidateXmlFileAndAttachErrorsAndFileToTransaction(tempXmlFilePath, "xml_schema.xml_schema.zip",
null, _dataRequest.TransactionId);
}
XmlDocument doc = new XmlDocument();
doc.Load(tempXmlFilePath);
AppendAuditLogEvent("Xml document loaded");
_headerDocumentHelper.AddPayload(_payloadOperation, doc.DocumentElement);
AppendAuditLogEvent("Header payload added");
_headerDocumentHelper.Serialize(tempXmlFilePath2);
AppendAuditLogEvent("Header serialized");
if (!File.Exists(tempXmlFilePath2))
{
throw new IOException("Header file does not exist: " + tempXmlFilePath2);
}
return(tempXmlFilePath2);
}
private void WriteToStorage()
{
EnsureFileExistence();
//var serVals = new Dictionary<Type, string>();
//foreach(var entry in StoredObject)
//{
// var serVal = _serializationHelper.Serialize(entry.Value).SerializedValue.Value;
// serVals.Add(entry.Key, serVal);
//}
var newContents = _serializationHelper.Serialize(StoredObject);
if (!newContents.Success)
{
throw new Exception("Could not serialize data for repository", newContents.FailureException);
}
File.WriteAllText(_storageFilePath, newContents.SerializedValue.Value);
}
internal string Execute(DateTime changeDate, string flowName, string targetXmlPath,
ISerializationHelper serializationHelper, ICompressionHelper compressionHelper,
IObjectsFromDatabase objectsFromDatabase,
IAppendAuditLogEvent appendAuditLogEvent)
{
appendAuditLogEvent.AppendAuditLogEvent("Querying TANKS data ...");
string whereQuery =
string.Format("FAC_SITE_IDEN IN (SELECT ST_FAC_IND FROM CHANGED_FACILITIES WHERE IS_DELETED = 0 AND UPPER(FLOW_TYPE) = UPPER('{0}') AND UPDATE_DATE >= '{1}')",
flowName, changeDate.ToString("dd-MMM-yyyy").ToUpper());
Dictionary <string, DbAppendSelectWhereClause> selectClauses = new Dictionary <string, DbAppendSelectWhereClause>();
selectClauses.Add("TANKS_FAC_SITE", new DbAppendSelectWhereClause(whereQuery, null));
List <TanksSubmissionDataType> dataList =
objectsFromDatabase.LoadFromDatabase <TanksSubmissionDataType>(_baseDao, selectClauses);
TanksSubmissionDataType data;
if (CollectionUtils.IsNullOrEmpty(dataList))
{
appendAuditLogEvent.AppendAuditLogEvent("Did not find any TANKS data in database.");
return(null);
}
else if (dataList.Count > 1)
{
throw new InvalidOperationException("More than one set of TANKS data was found in database.");
}
else
{
data = dataList[0];
if (CollectionUtils.IsNullOrEmpty(data.TanksFacilitySite))
{
appendAuditLogEvent.AppendAuditLogEvent("Did not find any tanks facilities.");
return(null);
}
else
{
appendAuditLogEvent.AppendAuditLogEvent("Found {0} facilities and {1} unique tanks.",
data.TanksFacilitySite.Length,
GetUniqueTankCount(data));
}
}
appendAuditLogEvent.AppendAuditLogEvent(
"Serializing transformed results to file (File = {0}).",
targetXmlPath);
serializationHelper.Serialize(data, targetXmlPath);
return(compressionHelper.CompressFile(targetXmlPath));
}
internal byte[] Execute(ICollection <string> allFlowList, ICollection <string> protectedFlowList,
ICollection <string> userProtectedFlowList, DateTime changeDate,
ISerializationHelper serializationHelper, HEREBaseService hereBaseService)
{
hereBaseService.AppendAuditLogEvent("Getting data.");
HERE10.ManifestDataSet ds = _dbService.GetManifestData(changeDate);
hereBaseService.AppendAuditLogEvent("Data retrieved. (Record Count = {0}).", ds.Manifest.Rows.Count);
hereBaseService.AppendAuditLogEvent("Transforming results.");
List <HERE10.HEREManifestItemDataType> manifestItems = new List <HERE10.HEREManifestItemDataType>();
foreach (HERE10.ManifestDataSet.ManifestRow manifestRow in ds.Manifest.Rows)
{
string flowCode = manifestRow.DataExchangeName;
if (ContainsFlowName(allFlowList, flowCode))
{
if (ContainsFlowName(protectedFlowList, flowCode))
{
if (!ContainsFlowName(userProtectedFlowList, flowCode))
{
// User does not have access to this flow
continue;
}
}
HERE10.HEREManifestItemDataType item = new HERE10.HEREManifestItemDataType();
item.TransactionIdentifier = manifestRow.TransactionId;
item.CreatedDate = manifestRow.CreatedDate;
item.DataExchangeNameText = manifestRow.DataExchangeName;
item.EndpointURLIdentifier = manifestRow.EndpointURL;
item.FullReplaceIndicator = manifestRow.FullReplaceIndicator;
item.SourceInfo = new HERE10.SourceInfoDataType();
item.SourceInfo.IsFacilitySourceIndicator = manifestRow.IsFacilitySourceIndicator;
item.SourceInfo.SourceSystemName = manifestRow.SourceSystemName;
manifestItems.Add(item);
}
}
HERE10.HEREManifestDataType manifest = new HERE10.HEREManifestDataType();
manifest.HEREManifestDetails = manifestItems.ToArray();
hereBaseService.AppendAuditLogEvent("Results transformed.");
return(serializationHelper.Serialize(manifest));
}
protected byte[] GetSubmittedDocumentList(out int rowCount)
{
SubmittedDocumentList list = GetSubmittedDocumentList();
rowCount = list.SubmittedDocuments.Length;
if (rowCount == 0)
{
AppendAuditLogEvent("Did not find any submitted documents");
}
else
{
AppendAuditLogEvent("Found {0} submitted documents", rowCount.ToString());
}
return(_serializationHelper.Serialize(list));
}
protected string GenerateSubmissionFile(EMTSDataType data)
{
string tempZipFilePath = _settingsProvider.NewTempFilePath(".zip");
string tempXmlFilePath = _settingsProvider.NewTempFilePath(".xml");
try
{
_serializationHelper.Serialize(data, tempXmlFilePath);
AppendAuditLogEvent("Generating submission file (with an exchange header) from results");
IHeaderDocument2Helper headerDocumentHelper;
GetServiceImplementation(out headerDocumentHelper);
// Configure the submission header helper
headerDocumentHelper.Configure(_authorName, _settingsProvider.NodeOrganizationName, EMTS_FLOW_NAME,
EMTS_FLOW_NAME, string.Empty, string.Empty, null);
string tempXmlFilePath2 = _settingsProvider.NewTempFilePath(".xml");
try
{
XmlDocument doc = new XmlDocument();
doc.Load(tempXmlFilePath);
headerDocumentHelper.AddPayload(string.Empty, doc.DocumentElement);
headerDocumentHelper.Serialize(tempXmlFilePath2);
_compressionHelper.CompressFile(tempXmlFilePath2, tempZipFilePath);
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath2);
}
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempZipFilePath);
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
}
return(tempZipFilePath);
}
protected string MakeHeaderFile(T dataObject)
{
string tempXmlFilePath = null, tempXmlFilePath2 = null;
try
{
ISettingsProvider settingsProvider;
GetServiceImplementation(out settingsProvider);
// Configure the submission header helper
_headerDocumentHelper.Configure(_author, _organization, _title, null, _contactInfo, null);
_headerDocumentHelper.AddNotifications(_notifications);
_headerDocumentHelper.AddPropery("RCRAInfoStateCode", _rcraInfoStateCode);
_headerDocumentHelper.AddPropery("RCRAInfoUserID", _rcraInfoUserId);
tempXmlFilePath = settingsProvider.NewTempFilePath(".xml");
_serializationHelper.Serialize(dataObject, tempXmlFilePath);
if (_validateXml)
{
ValidateXmlFileAndAttachErrorsAndFileToTransaction(tempXmlFilePath, "xml_schema.xml_schema.zip",
null, _dataRequest.TransactionId);
}
XmlDocument doc = new XmlDocument();
doc.Load(tempXmlFilePath);
_headerDocumentHelper.AddPayload(_payloadOperation, doc.DocumentElement);
tempXmlFilePath2 = settingsProvider.NewTempFilePath(".xml");
_headerDocumentHelper.Serialize(tempXmlFilePath2);
return(tempXmlFilePath2);
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempXmlFilePath2);
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
}
}
protected virtual string AddExchangeDocumentHeader(object data, bool doCompress, string docTransactionId)
{
string tempXmlFilePath = _settingsProvider.NewTempFilePath(".xml");
try
{
ExceptionUtils.ThrowIfNull(data, "data");
_serializationHelper.Serialize(data, tempXmlFilePath);
}
catch (Exception ex)
{
AppendAuditLogEvent("Failed to serialized data of type \"{0}\" with exception: {1}",
data.GetType().Name, ExceptionUtils.GetDeepExceptionMessage(ex));
throw;
}
return(AddExchangeDocumentHeader(tempXmlFilePath, doCompress, docTransactionId));
}
public virtual PaginatedContentResult ProcessQuery(string requestId)
{
LazyInit();
ValidateRequest(requestId);
var parameters = new Dictionary <string, string>();
parameters[WQXPluginBase.PARAM_ORGANIZATION_IDENTIFIER_KEY] = _organizationIdentifier;
string executionInfo, transactionId, errorDetails;
AppendAuditLogEvent("Executing schedule \"{0}\" for WQX organization \"{1}\"", _scheduleName, _organizationIdentifier);
var scheduledItem = _scheduleManager.ExecuteSchedule(_scheduleName, parameters, out transactionId, out executionInfo, out errorDetails);
AppendAuditLogEvent("Successfully executed schedule \"{0}\" for WQX organization \"{1}\"", _scheduleName, _organizationIdentifier);
var resultData = new WQXExecuteScheduleResult();
resultData.LocalTransactionId = transactionId;
CommonTransactionStatusCode status;
EndpointVersionType endpointVersion;
string endpointUrl;
resultData.NetworkTransactionId =
_transactionManager.GetNetworkTransactionStatus(transactionId, out status, out endpointVersion, out endpointUrl);
resultData.NodeEndpointUrl = endpointUrl;
resultData.NodeEndpointVersion = endpointVersion;
resultData.ActivityDetails = executionInfo;
resultData.ErrorDetails = errorDetails;
if (string.Equals(resultData.NetworkTransactionId, resultData.LocalTransactionId))
{
resultData.NetworkTransactionId = null;
}
var bytes = _serializationHelper.Serialize(resultData);
//File.WriteAllBytes(@"D:\Temp\Exec.xml", bytes);
PaginatedContentResult result = new PaginatedContentResult(0, 1, true, CommonContentType.XML, bytes);
return(result);
}
protected virtual string GenerateSubmissionFile(BeachDataSubmissionDataType data)
{
ISettingsProvider settingsProvider;
GetServiceImplementation(out settingsProvider);
string tempXmlFilePath = settingsProvider.NewTempFilePath(".xml");
try
{
AppendAuditLogEvent("Generating submission file from results");
_serializationHelper.Serialize(data, tempXmlFilePath);
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
throw;
}
return(tempXmlFilePath);
}
public PaginatedContentResult ProcessQuery(string requestId)
{
LOG.DebugEnter(MethodBase.GetCurrentMethod(), requestId);
LazyInit();
DataRequest request = _requestManager.GetDataRequest(requestId);
object returnData = GetObjectFromRequest(request);
LOG.Debug("Creating PaginatedContentResult");
PaginatedContentResult result = new PaginatedContentResult();
result.Paging = new PaginationIndicator(request.RowIndex, request.MaxRowCount, true);
LOG.Debug("Serializing data");
result.Content = new SimpleContent(CommonContentType.XML, _serializationHelper.Serialize(returnData));
LOG.Debug("OK");
return(result);
}
internal string Execute(DateTime changeDate, string targetXmlPath, ISerializationHelper serializationHelper,
ICompressionHelper compressionHelper, HEREBaseService hereBaseService)
{
hereBaseService.AppendAuditLogEvent("Getting data.");
Tier2DataSet ds = _dbService.GetTier2DataSet(changeDate);
hereBaseService.AppendAuditLogEvent("Data retrieved. (Record Count = {0}).",
ds.T2_SUBMISSION.Rows.Count);
hereBaseService.AppendAuditLogEvent("Transforming results.");
TierIIDataType facs = Tier2Transform.Transform(ds);
if (facs == null || facs.Submission == null || facs.Submission.Length == 0)
{
return(null);
}
else
{
hereBaseService.AppendAuditLogEvent("Results transformed. (Record Count = {0}).",
facs.Submission.Length);
hereBaseService.AppendAuditLogEvent("Serializing transformed results to file (File = {0}).",
targetXmlPath);
serializationHelper.Serialize(facs, targetXmlPath);
hereBaseService.AppendAuditLogEvent("Transformed results Serialized.");
if (compressionHelper != null)
{
return(compressionHelper.CompressFile(targetXmlPath));
}
else
{
return(targetXmlPath);
}
}
}
protected virtual string GenerateQuerySolicitFile(BeachDataSubmissionDataType data)
{
string tempXmlFilePath = _settingsProvider.NewTempFilePath(".xml");
string tempZipFilePath = _settingsProvider.NewTempFilePath(".zip");
try
{
AppendAuditLogEvent("Generating submission file from results");
_serializationHelper.Serialize(data, tempXmlFilePath);
_compressionHelper.CompressFile(tempXmlFilePath, tempZipFilePath);
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempZipFilePath);
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
}
return(tempZipFilePath);
}
public static string RemoveHeaderFile(string tempXmlFilePath, string tempFolderPath, ISerializationHelper serializationHelper)
{
string tempXmlFilePath2 = null;
try
{
HeaderDocumentHelperQualified headerDocumentHelper = new HeaderDocumentHelperQualified();
headerDocumentHelper.SerializationHelper = serializationHelper;
XmlDocument doc = new XmlDocument();
doc.Load(tempXmlFilePath);
if (headerDocumentHelper.TryLoad(doc.DocumentElement))
{
XmlElement element = headerDocumentHelper.GetPayload("Update-Insert");
//Serialize to new file
string fileName = Guid.NewGuid().ToString();
tempXmlFilePath2 = Path.Combine(tempFolderPath, WQX_FILE_PREFIX + fileName + ".xml");
serializationHelper.Serialize(element, tempXmlFilePath2);
return(tempXmlFilePath2);
}
else
{
throw new Exception("Unable to load document element.");
}
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempXmlFilePath2);
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
}
}
private List <VerificationFailure> ProcessArg(object arg)
{
var res = new List <VerificationFailure>();
var argType = arg.GetType();
if (_dalHelper.IsUnserializable(argType))
{
res.Add(new TypeSerializationFailure(argType));
}
else
{
;
var serResult = _serializer.Serialize(arg);
if (!serResult.Success)
{
_dalHelper.AddUnserializableType(argType);
res.Add(new TypeSerializationFailure(argType));
}
}
return(res);
}
public void DoRequestUpdate(AccountAuthorizationRequest request, string adminName, bool doAccept)
{
request.Response.AuthorizationGeneratedOn = DateTime.Now;
AuthorizationResponse response = GetAuthorizationResponse(request, doAccept);
byte[] authorizationResponsContent = _serializationHelper.Serialize(response);
Document document = new Document(response.GetType().Name + ".xml", CommonContentType.XML, authorizationResponsContent);
string statusDetail = string.Format("{0} {1} authorization request from user \"{2} ({3})\"",
adminName, doAccept ? "accepted" : "rejected",
request.FullName, request.NaasAccount);
TransactionTemplate.Execute(delegate
{
Save(request);
_documentManager.AddDocument(request.TransactionId, CommonTransactionStatusCode.Completed,
statusDetail, document);
_transactionDao.SetTransactionStatus(request.TransactionId, CommonTransactionStatusCode.Completed,
statusDetail, true);
return(null);
});
}
protected string MakeHeaderFile(T dataObject)
{
string tempXmlFilePath = null, tempXmlFilePath2 = null;
try
{
ISettingsProvider settingsProvider;
GetServiceImplementation(out settingsProvider);
// Configure the submission header helper
_headerDocumentHelper.Configure(_author, _organization, _title, null, _contactInfo, null);
tempXmlFilePath = settingsProvider.NewTempFilePath(".xml");
_serializationHelper.Serialize(dataObject, tempXmlFilePath);
ValidateXmlFile(tempXmlFilePath);
XmlDocument doc = new XmlDocument();
doc.Load(tempXmlFilePath);
_headerDocumentHelper.AddPayload(_payloadOperation, doc.DocumentElement);
tempXmlFilePath2 = settingsProvider.NewTempFilePath(".xml");
_headerDocumentHelper.Serialize(tempXmlFilePath2);
return(tempXmlFilePath2);
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempXmlFilePath2);
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
}
}
protected byte[] GetServices(ServiceType returnServiceTypes, out int rowCount, out CommonContentType contentType)
{
NetworkNodeType networkNodeType = GetServices(returnServiceTypes);
rowCount = networkNodeType.NodeServiceList.Length;
NetworkNodeListType networkNodeListType = new NetworkNodeListType();
networkNodeListType.NetworkNodeDetails = new NetworkNodeType[1] {
networkNodeType
};
byte[] content = _serializationHelper.Serialize(networkNodeListType);
contentType = CommonContentType.XML;
content = CheckToXsltTransformContent(content, "xml_schema.XsltTransforms.zip",
_xsltTransformName, ref contentType);
string docId =
_documentManager.AddDocument(_dataRequest.TransactionId, CommonTransactionStatusCode.Completed,
null, new Document(null, contentType, content));
return(content);
}
protected virtual bool DoXmlLoad(out string submitFilePath)
{
submitFilePath = null;
Type mappingAttributesType = typeof(Windsor.Node2008.WNOSPlugin.ICISNPDES_56.MappingAttributes);
IDictionary <string, DbAppendSelectWhereClause> selectClauses = Windsor.Node2008.WNOSPlugin.ICISNPDES_56.PayloadData.GetDefaultSelectClauses(_stagingDao);
List <Windsor.Node2008.WNOSPlugin.ICISNPDES_56.PayloadData> payloads =
_objectsFromDatabase.LoadFromDatabase <Windsor.Node2008.WNOSPlugin.ICISNPDES_56.PayloadData>(_stagingDao, selectClauses, mappingAttributesType);
// Remove payloads that don't contain any data
if (payloads != null)
{
for (int i = payloads.Count - 1; i >= 0; i--)
{
if (CollectionUtils.IsNullOrEmpty(payloads[i].Items))
{
// TSM: Is this log really necessary?
//AppendAuditLogEvent(string.Format("The payload with operation \"{0}\" will not be included in the submission because it does not contain any data", payloads[i].Operation.ToString()));
payloads.RemoveAt(i);
}
}
}
if (CollectionUtils.IsNullOrEmpty(payloads))
{
_submissionTrackingDataType.WorkflowStatus = TransactionStatusCode.Completed;
_submissionTrackingDataType.WorkflowStatusMessage = "The staging database does not contain any payloads to submit";
AppendAuditLogEvent(_submissionTrackingDataType.WorkflowStatusMessage + ", exiting plugin ...");
SubmissionTrackingTableHelper.Update(_stagingDao, _submissionTrackingDataTypePK, _submissionTrackingDataType);
return(false);
}
AppendAuditLogEvent("The following ICIS payload(s) were loaded from the database: {0}", GetPayloadsDescription(payloads));
Windsor.Node2008.WNOSPlugin.ICISNPDES_56.Document document = new Document();
document.Payload = payloads.ToArray();
document.Header = CreateHeader();
string tempFolder = _settingsProvider.CreateNewTempFolderPath();
string tempXmlPath = Path.Combine(tempFolder, ICIS_SUBMISSION_XML_FILENAME);
string tempZipPath = Path.Combine(tempFolder, ICIS_SUBMISSION_ZIP_FILENAME);
try
{
AppendAuditLogEvent("Serializing ICIS payload(s) to xml ...");
_serializationHelper.Serialize(document, tempXmlPath);
if (_validateXml)
{
ValidateXmlFileAndAttachErrorsAndFileToTransaction(tempXmlPath, "xml_schema.xml_schema.zip",
null, _dataRequest.TransactionId);
}
_compressionHelper.CompressFile(tempXmlPath, tempZipPath);
_documentManager.AddDocument(_dataRequest.TransactionId, CommonTransactionStatusCode.Completed, null, tempZipPath);
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempZipPath);
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlPath);
}
submitFilePath = tempZipPath;
return(true);
}
protected string GenerateSubmissionFile()
{
string authorName, organizationName;
bool isProductionSubmission;
CERSDataType data = GetCERSData.GetData(this, _databasePath, _dataCategory, out authorName, out organizationName, out isProductionSubmission);
string tempZipFilePath = _settingsProvider.NewTempFilePath(".zip");
string tempXmlFilePath = _settingsProvider.NewTempFilePath(".xml");
string tempXmlCleanFilePath = _settingsProvider.NewTempFilePath(".xml");
string validationResultsFilePath;
// Required for the EIS backend parser:
//XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
//ns.Add("cer", "http://www.exchangenetwork.net/schema/cer/1");
try
{
//_serializationHelper.SerializerNamespaces = ns;
_serializationHelper.Serialize(data, tempXmlFilePath);
XmlDocument xsl = new XmlDocument();
xsl.LoadXml(XSL_REMOVE_EMPTY_TAGS); // constant contains the XSL above
System.Xml.Xsl.XslCompiledTransform transform = new System.Xml.Xsl.XslCompiledTransform();
transform.Load(xsl);
transform.Transform(tempXmlFilePath, tempXmlCleanFilePath);
validationResultsFilePath = ValidateXmlFile(tempXmlCleanFilePath, "xml_schema.CER_Schema_v1.2.zip", null);
if (validationResultsFilePath == null)
{
_passedSchemaValidation = true;
}
else
{
_passedSchemaValidation = false;
_documentManager.AddDocument(_dataRequest.TransactionId,
CommonTransactionStatusCode.Failed,
null, validationResultsFilePath);
}
AppendAuditLogEvent("Generating submission file (with an exchange header) from results");
IHeaderDocument2Helper headerDocumentHelper;
GetServiceImplementation(out headerDocumentHelper);
//headerDocumentHelper.SerializerNamespaces = ns;
// Configure the submission header helper
headerDocumentHelper.Configure(authorName, organizationName, "EIS", "EIS_v1_0", string.Empty,
string.Empty, null);
DataCategory submissionDataCategory = data.DataCategory;
headerDocumentHelper.AddPropery(SUBMISSION_TYPE_HEADER_KEY,
isProductionSubmission ? PRODUCTION_SUBMISSION_TYPE_NAME : QA_SUBMISSION_TYPE_NAME);
headerDocumentHelper.AddPropery(DATA_CATEGORY_HEADER_KEY,
EnumUtils.ToDescription(submissionDataCategory));
string tempXmlFilePath2 = _settingsProvider.NewTempFilePath(".xml");
try
{
XmlDocument doc = new XmlDocument();
doc.Load(tempXmlCleanFilePath);
headerDocumentHelper.AddPayload(string.Empty, doc.DocumentElement);
headerDocumentHelper.Serialize(tempXmlFilePath2);
_compressionHelper.CompressFile(tempXmlFilePath2, tempZipFilePath);
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath2);
}
}
catch (Exception)
{
FileUtils.SafeDeleteFile(tempZipFilePath);
throw;
}
finally
{
FileUtils.SafeDeleteFile(tempXmlFilePath);
}
return(tempZipFilePath);
}
