public override XElement Process(RegulatorActionItemQueryArguments args)
{
Regulator regulator = null;
TransactionScope.WriteQueryArguments(args);
if (args.RegulatorCode.HasValue)
{
regulator = Repository.Regulators.GetByEDTIdentityKey(args.RegulatorCode.Value);
if (regulator == null)
{
throw new Exception("The specified RegulatorCode \"" + args.RegulatorCode + "\" is invalid.");
}
TransactionScope.Connect(regulator);
}
var data = Repository.Events.SearchActionItems(args.RequestedOnStart, args.RequestedOnEnd, args.CERSID, organizationCode: args.OrganizationCode, typeID: args.TypeID, completed: args.Completed);
RegulatorActionItemQueryXmlSerializer serializer = new RegulatorActionItemQueryXmlSerializer(Repository);
XElement result = serializer.Serialize(TransactionScope.Transaction, data);
TransactionScope.Complete(EDTTransactionStatus.Accepted);
try
{
TransactionScope.SaveXml(result, EDTTransactionXmlDirection.Outbound);
}
catch { }
return(result);
}
protected virtual void UpdateFacilityRegulatorSubmittalElement(Facility facility, FacilitySubmittalElementPacket <RegulatorFacilitySubmittalElementHeaderXmlObject> fsePacket)
{
FacilityRegulatorSubmittalElement frse = Repository.FacilityRegulatorSubmittalElements.GetForFacility(facility.CERSID, fsePacket.FacilitySubmittalElement.SubmittalElementID);
var status = (SubmittalElementStatus)fsePacket.FacilitySubmittalElement.StatusID;
var type = (SubmittalElementType)fsePacket.FacilitySubmittalElement.SubmittalElementID;
var submittedOn = fsePacket.FacilitySubmittalElement.SubmittedDateTime.Value;
bool frseUpdated = false;
//if this submittal is accepted, then lets see if this is the most recent accepted.
//if so, then update the FRSE with the LastAccepted PK and date/time.
if (status == SubmittalElementStatus.Accepted)
{
var lastAccepted = GetMostRecentFSE(fsePacket);
if ((lastAccepted != null && submittedOn > lastAccepted.SubmittedDateTime.Value) ||
(frse.LastAcceptedFacilitySubmittalElementOn == null || (frse.LastAcceptedFacilitySubmittalElementOn != null && frse.LastAcceptedFacilitySubmittalElementOn.Value < fsePacket.FacilitySubmittalElement.SubmittalActionDateTime)))
{
frse.LastAcceptedFacilitySubmittalElementID = fsePacket.FacilitySubmittalElement.ID;
frse.LastAcceptedFacilitySubmittalElementOn = fsePacket.FacilitySubmittalElement.SubmittalActionDateTime;
frseUpdated = true;
}
}
//now see if this is the most recent facility submittal element received for this submittal element.
//if so, then lets update the LastSubmitted fields.
var results = Repository.FacilitySubmittalElements.Search(CERSID: facility.CERSID, type: type);
results = from r in results where r.StatusID != (int)SubmittalElementStatus.Draft && r.ID != fsePacket.FacilitySubmittalElement.ID select r;
var lastFSE = results.OrderByDescending(p => p.SubmittedDateTime).FirstOrDefault();
if ((lastFSE != null && submittedOn > lastFSE.SubmittedDateTime.Value) ||
(frse.LastSubmittedFacilitySubmittalElementOn == null || (frse.LastSubmittedFacilitySubmittalElementOn != null && frse.LastSubmittedFacilitySubmittalElementOn.Value < fsePacket.FacilitySubmittalElement.SubmittedDateTime)))
{
frse.LastSubmittedFacilitySubmittalElementID = fsePacket.FacilitySubmittalElement.ID;
frse.LastSubmittedFacilitySubmittalElementOn = fsePacket.FacilitySubmittalElement.SubmittedDateTime;
frseUpdated = true;
}
Repository.FacilityRegulatorSubmittalElements.Save(frse);
//update the last Fac Info
if (fsePacket.FacilitySubmittalElement.SubmittalElementID == (int)SubmittalElementType.FacilityInformation)
{
if (ServiceManager.BusinessLogic.SubmittalElements.SetLastFacilityInfoSubmittal(fsePacket.FacilitySubmittalElement))
{
TransactionScope.Connect(fsePacket.FacilitySubmittalElement.Facility);
}
frseUpdated = true;
}
if (frseUpdated)
{
TransactionScope.Connect(frse);
}
}
public override XElement Process(RegulatorOrganizatonQueryAdapterArguments args)
{
Regulator regulator = null;
TransactionScope.WriteQueryArguments(args);
if (args.RegulatorCode != null)
{
regulator = Repository.Regulators.GetByEDTIdentityKey(args.RegulatorCode.Value);
if (regulator == null)
{
throw new Exception("The specified RegulatorCode \"" + args.RegulatorCode + "\" is invalid.");
}
TransactionScope.Connect(regulator);
}
XElement result = null;
IEnumerable <OrganizationGridViewModel> organizationData = null;
IEnumerable <FacilityGridViewModel> facilityData = null;
int total = 0;
organizationData = Repository.Organizations.GridSearch(
args.OrganizationName,
args.OrganizationCode,
args.OrganizationHeadquarters,
(int)OrganizationStatus.Active,
CERSID: args.CERSID,
nameSearchOption: StringSearchOption.StartsWith
);
if (args.EstablishedSince.HasValue)
{
organizationData = from d in organizationData where d.CreatedOnDate >= args.EstablishedSince select d;
}
total = organizationData.Count();
TransactionScope.WriteActivity("Query returned " + total + " Organization(s)");
if (args.IncludeFacilities)
{
TransactionScope.WriteActivity("Basic facility data requested. Fetching...");
List <int> organizationIds = organizationData.Select(p => p.ID).ToList();
facilityData = Repository.Facilities.GridSearch().Where(p => organizationIds.Contains(p.OrganizationID)).ToList();
}
RegulatorOrganizationQueryXmlSerializer serializer = new RegulatorOrganizationQueryXmlSerializer(Repository);
result = serializer.Serialize(TransactionScope.Transaction, organizationData, total, facilityData);
TransactionScope.Complete(EDTTransactionStatus.Accepted);
TransactionScope.SaveXml(result, EDTTransactionXmlDirection.Outbound);
return(result);
}
public override XElement Process(RegulatorFacilitySubmittalQueryArguments args)
{
TransactionScope.WriteQueryArguments(args);
var regulator = Repository.Regulators.GetByEDTIdentityKey(args.RegulatorCode);
if (regulator == null)
{
throw new Exception("The specified RegulatorCode \"" + args.RegulatorCode + "\" is invalid.");
}
if (args.Statuses.Contains(SubmittalElementStatus.Draft))
{
throw new Exception("You cannot download Facility Submittals with a Status of Draft");
}
bool useFSEXmlCache = EDTConfig.Serialization.RegulatorFacilitySubmittalQuery.UseXmlCache;
//attach the regulator to this transaction so that we know that this regulator made this transaction easily.
TransactionScope.Connect(regulator);
List <FacilitySubmittalElement> fses = new List <FacilitySubmittalElement>();
fses.AddRange(Repository.FacilitySubmittalElements.EDTSearch(
args.SubmittedOnStart,
args.SubmittedOnEnd,
args.SubmittalElementType,
args.CERSID,
regulator.ID,
args.SubmittalActionOnStart,
args.SubmittalActionOnEnd,
args.Statuses.ToArray()
).ToList()
);
XmlSerializationResult result = null;
try
{
result = Serializer.Serialize(fses, TransactionScope.Transaction, useFSEXmlCache: useFSEXmlCache);
TransactionScope.Complete(EDTTransactionStatus.Accepted);
Serializer.UpdateTransactionStatus(result, TransactionScope.Transaction);
}
catch (Exception ex)
{
TransactionScope.WriteActivity("Unable to serialize the data.", ex);
TransactionScope.WriteMessage("Unable to serialize the data.", ex);
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
TransactionScope.SaveXml(result.Xml, EDTTransactionXmlDirection.Outbound);
return(result.Xml);
}
/// <summary>
/// Method accepts a list of Regulator IDs and binds the current EDTTransaction
/// (defined in the TransactionScope) to those Regulators by calling
/// TransactionScope.ConnectRegulatorToTransaction(regulatorID) for each.
/// </summary>
/// <param name="regulatorIDList"></param>
public void GenerateRegulatorEDTTransactions(List <int> regulatorIDList)
{
if (regulatorIDList.Distinct() == null)
{
throw new ArgumentNullException("regulatorIDList.Distinct()");
}
// Generate and bind an instance of RegulatorEDTTransaction to EDTTransaction
// for each distinct Regulator ID found:
foreach (var regulatorID in regulatorIDList.Distinct())
{
TransactionScope.Connect(regulatorID);
}
}
protected virtual void CommitChanges(RegulatorXmlObjectPacket <RegulatorFacilityMetadataPackage> package)
{
//if no errors, then submit to the database.
if (!package.Packet.Workspace.Messages.HasErrors())
{
foreach (var frse in package.Packet.Workspace.FacilityRegulatorSubmittalElements)
{
TransactionScope.Connect(frse);
Repository.FacilityRegulatorSubmittalElements.Save(frse);
}
if (package.Packet.Workspace.CERSFacilityGeoPoint != null)
{
if (Repository.CERSFacilityGeoPoints.GetByID(package.Packet.Workspace.CERSFacilityGeoPoint.CERSID) == null)
{
// have to create and not save because primary key is not zero
Repository.CERSFacilityGeoPoints.Create(package.Packet.Workspace.CERSFacilityGeoPoint);
}
else
{
// record already exists
Repository.CERSFacilityGeoPoints.Update(package.Packet.Workspace.CERSFacilityGeoPoint);
}
}
bool facilityUpdates = false;
if (!string.IsNullOrWhiteSpace(package.Packet.FacilityID))
{
package.Packet.Workspace.Facility.FacilityID = package.Packet.FacilityID;
facilityUpdates = true;
}
if (!string.IsNullOrWhiteSpace(package.Packet.FacilityRegulatorKey))
{
package.Packet.Workspace.Facility.FacilityRegulatorKey = package.Packet.FacilityRegulatorKey;
facilityUpdates = true;
}
if (facilityUpdates)
{
Repository.Facilities.Save(package.Packet.Workspace.Facility);
TransactionScope.Connect(package.Packet.Workspace.Facility);
UpdateDraftFacilityInformation(package);
}
}
}
public override XElement Process(RegulatorFacilityTransferQueryArguments args)
{
Regulator regulator = null;
TransactionScope.WriteQueryArguments(args);
if (args.RegulatorCode.HasValue)
{
regulator = Repository.Regulators.GetByEDTIdentityKey(args.RegulatorCode.Value);
if (regulator == null)
{
throw new Exception("The specified RegulatorCode \"" + args.RegulatorCode + "\" is invalid.");
}
TransactionScope.Connect(regulator);
}
else
{
throw new ArgumentException("Missing RegulatorCode", "RegulatorCode");
}
int?organizationID = null;
if (args.OrganizationCode.HasValue)
{
var organization = Repository.Organizations.GetByEDTIdentityKey(args.OrganizationCode.Value);
if (organization != null)
{
organizationID = organization.ID;
}
}
var data = Repository.FacilityTransferHistories.GridSearch(args.CERSID, regulator.ID, organizationID, args.OccurredOnStart, args.OccurredOnEnd, args.AssumedOwnershipOnStart, args.AssumedOwnershipOnEnd);
RegulatorFacilityTransferQueryXmlSerializer serializer = new RegulatorFacilityTransferQueryXmlSerializer(Repository);
XElement result = serializer.Serialize(TransactionScope.Transaction, data.ToList());
TransactionScope.Complete(EDTTransactionStatus.Accepted);
TransactionScope.SaveXml(result, EDTTransactionXmlDirection.Outbound);
return(result);
}
protected virtual void ProcessFacilityRegulatorSubmittalElementMetadata(Facility facility, FacilitySubmittalElementPacket <RegulatorFacilitySubmittalElementHeaderXmlObject> fsePacket)
{
//if the xml data included a new NextDueDate and/or Reporting Requirement lets find the FacilityRegulatorSubmittalElement (FRSE) and update it
//with the new data bits.
if (fsePacket.Header.NextDueDate != null)
{
//find the FRSE for this Facility and Submittal Element Type.
fsePacket.FacilityRegulatorSubmittalElement = Repository.FacilityRegulatorSubmittalElements.GetForFacility(facility, fsePacket.Type);
//if NextDueDate was specified lets update it.
if (fsePacket.Header.NextDueDate != null)
{
//=> SubmittalActionDateTime
fsePacket.FacilityRegulatorSubmittalElement.NextDueDate = fsePacket.Header.NextDueDate;
TransactionScope.Connect(fsePacket.FacilityRegulatorSubmittalElement);
}
//update the FRSE
Repository.FacilityRegulatorSubmittalElements.Save(fsePacket.FacilityRegulatorSubmittalElement);
}
}
public override XElement Process(RegulatorFacilityQueryArguments args)
{
Regulator regulator = null;
TransactionScope.WriteQueryArguments(args);
if (args.RegulatorCode != null)
{
regulator = Repository.Regulators.GetByEDTIdentityKey(args.RegulatorCode.Value);
if (regulator == null)
{
throw new Exception("The specified RegulatorCode \"" + args.RegulatorCode + "\" is invalid.");
}
TransactionScope.Connect(regulator);
}
XElement result = null;
IEnumerable <FacilityQueryResult> data = null;
int total = 0;
data = Repository.Facilities.EDTFacilityQuery(args.OrganizationCode, args.CERSID, args.RegulatorCode, args.CreatedOnStart, args.CreatedOnEnd, args.Street, args.City, args.ZIP);
total = data.Count();
if (total > MaximumResultItems)
{
data = data.Take(MaximumResultItems);
}
RegulatorFacilityQueryXmlSerializer serializer = new RegulatorFacilityQueryXmlSerializer(Repository);
result = serializer.Serialize(TransactionScope.Transaction, data, total);
TransactionScope.Complete(EDTTransactionStatus.Accepted);
TransactionScope.SaveXml(result, EDTTransactionXmlDirection.Outbound);
return(result);
}
public XElement Process(Stream stream, int regulatorCode)
{
Regulator contextRegulator = Repository.Regulators.GetByEDTIdentityKey(regulatorCode);
if (contextRegulator == null)
{
throw new ArgumentException("RegulatorCode does not contain a valid number.", "regulatorCode");
}
//Connect the regulator after we verified it exists.
TransactionScope.Connect(contextRegulator);
//this endpoint supports multiple versions of the schema simultaneously.
IXmlSchemaMetadata inputSchemaMetadata = null;
IXmlSchemaMetadata outputSchemaMetadata = null;
string version = null;
RegulatorFacilityCreateResponseXmlSerializer responseSerializer = new RegulatorFacilityCreateResponseXmlSerializer(Repository);
//lets default to Trial mode in case the XML is so messed up we can't parse it, and this is obviously less danagerous than
//a Commit.
RegulatorFacilityCreateMode mode = RegulatorFacilityCreateMode.Trial;
//declare the package to be use to inflate the XML.
RegulatorXmlObjectPacket <RegulatorFacilityCreateMode, FacilityCreatePackage> package = null;
XmlSchemaValidationResult schemaValidationResult = null;
var rfcXml = ConvertStreamToXDocument(stream);
if (rfcXml != null)
{
string xml = rfcXml.ToString();
TransactionScope.SaveXml(xml, EDTTransactionXmlDirection.Inbound);
TransactionScope.WriteActivity("XML Document is validating...");
//get the root element of the doc (should be named RegulatorFacilityCreate).
var rootElement = rfcXml.Root;
//try and obtain the targetNamespace
var targetNamespace = rootElement.GetDefaultNamespace();
if (string.IsNullOrWhiteSpace(targetNamespace.NamespaceName))
{
//couldn't obtain the schema we need because the root node didn't have a default non-prefixed xmlns attribute.
//lets see of the document is using prefixes and look for the xmlns:cers="" attribute.
targetNamespace = rootElement.GetNamespaceOfPrefix("cers");
}
//if we have no targetNamespace then we should not proceed any further.
if (targetNamespace == null || targetNamespace.NamespaceName == string.Empty)
{
TransactionScope.WriteMessage("Unable to resolve the targetNamespace of the received XML data.", EDTTransactionMessageType.Error);
throw new Exception("Unable to resolve the targetNamespace of the received XML data.");
}
//find the metadata for the RegulatorFacilityCreate schema with the specified targetNamespace.
inputSchemaMetadata = XmlSchemas.GetSchemaMetdataForNamespace(XmlSchema.RegulatorFacilityCreate, targetNamespace); //XmlSchemas.GetSchemaMetadata( XmlSchema.RegulatorFacilityCreate, version );
if (inputSchemaMetadata == null)
{
TransactionScope.WriteMessage("Unable to find a RegulatorFacilityCreate schema with the specified namespace: " + targetNamespace.NamespaceName, EDTTransactionMessageType.Error);
throw new Exception("Unable to find a RegulatorFacilityCreate schema with the specified version: " + version);
}
//the outgoing schema version is dependant on the version specified in the input schema.
//so parse the version and then look for the appropriate output (response schema).
version = targetNamespace.ExtractVersion();
//now try and find the response schema with the version parsed from the targetSchema.
outputSchemaMetadata = XmlSchemas.GetSchemaMetadata(XmlSchema.RegulatorFacilityCreateResponse, version);
if (outputSchemaMetadata == null)
{
TransactionScope.WriteMessage("Unable to find a RegulatorFacilityCreateResponse schema with the specified version: " + version, EDTTransactionMessageType.Error);
throw new Exception("Unable to find a RegulatorFacilityCreateResponse schema with the specified version: " + version);
}
schemaValidationResult = xml.IsValidAgainstSchema(inputSchemaMetadata);
if (!schemaValidationResult.IsValid)
{
//make a new package so we have a storage area for the errors to be shipped back in the response xml.
package = new RegulatorXmlObjectPacket <RegulatorFacilityCreateMode, FacilityCreatePackage>();
//package is invalid due to schema validation errors, update the transaction status, and write some diagnostic information.
//Merge in the schema validation error messages and associate them with the transaction.
TransactionScope.WriteActivity("XML Document is not valid against the schema.");
package.Packet.Workspace.Messages.Add("XML Document is not valid against the schema.", FacilityOperationMessageType.Error);
foreach (var error in schemaValidationResult.Errors)
{
TransactionScope.WriteMessage("Schema Validation Error: " + error, EDTTransactionMessageType.Error);
package.Packet.Workspace.Messages.Add("Schema Validation Error: " + error, FacilityOperationMessageType.Error);
}
TransactionScope.WriteMessage("XML document does not validate against the schema.", EDTTransactionMessageType.Error);
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
else
{
TransactionScope.WriteActivity("XML Document is valid against the schema.");
//deserialize the data into the object structure.
RegulatorFacilityCreateXmlSerializer serializer = new RegulatorFacilityCreateXmlSerializer(Repository);
package = serializer.Deserialize(rfcXml);
package.Packet.Version = version; //add in the version 4/1/2014.
mode = package.Mode;
// error if DataCollectionDate is less than 1970 and greater than today at 11:59
if (package.Packet.CERSPoint != null &&
package.Packet.CERSPoint.DataCollectionDate != null &&
(package.Packet.CERSPoint.DataCollectionDate < new DateTime(1970, 1, 1) || package.Packet.CERSPoint.DataCollectionDate > DateTime.Now.AddDays(1).AddTicks(-1)))
{
package.Packet.Workspace.Messages.Add("DataCollectionDate is out of range.", FacilityOperationMessageType.Error);
}
if (!package.Packet.HasErrors())
{
ServiceManager.Facilities.Create(package.Packet, regulatorCode, mode, true);
if (mode == RegulatorFacilityCreateMode.Commit && package.Packet.Workspace.FacilityCreated)
{
TransactionScope.Connect(package.Packet.Workspace.Facility);
}
}
//if the package had errors, set rejected, otherwise set accepted.
if (package.Packet.HasErrors())
{
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
else
{
TransactionScope.Complete(EDTTransactionStatus.Accepted);
}
}
}
//prepare our output response XML.
XElement responseXml = responseSerializer.PreparePackage(TransactionScope.Transaction, outputSchemaMetadata);
responseSerializer.AddTransaction(responseXml, TransactionScope.Transaction, mode);
//we should always have a package (unless schema validation failed).
if (package != null)
{
//add the result hive to the root node if we created a facility (or virtually did in trial mode)
responseSerializer.AddResult(responseXml, package.Packet, mode);
//if using the 1/06 schema version...
if (!string.IsNullOrWhiteSpace(package.Packet.Version) && (package.Packet.Version.IndexOf("1/06") > -1))
{
responseSerializer.AddPotentialDuplicates(responseXml, package.Packet);
}
}
//add the messages generated during the process.
responseSerializer.AddMessages(responseXml, package.Packet);
TransactionScope.SaveXml(responseXml, EDTTransactionXmlDirection.Outbound);
return(responseXml);
}
public XElement Process(Stream stream, int regulatorCode)
{
//make serializers needed
RegulatorFacilitySubmittalResponseXmlSerializer responseSerializer = new RegulatorFacilitySubmittalResponseXmlSerializer(Repository);
RegulatorFacilitySubmittalActionNotificationXmlSerializer serializer = new RegulatorFacilitySubmittalActionNotificationXmlSerializer(Repository);
//contextRegulator is always the regulator this Processor is working under the context of. In this case, the assumption is, this Regulator is
//ALWAYS a CUPA.
Regulator contextRegulator = Repository.Regulators.GetByEDTIdentityKey(regulatorCode);
if (contextRegulator == null)
{
throw new ArgumentException("RegulatorCode does not contain a valid number.", "regulatorCode");
}
TransactionScope.Connect(contextRegulator);
XmlSchemaValidationResult schemaValidationResult = null;
var rfsanXml = ConvertStreamToXDocument(stream);
if (rfsanXml != null)
{
string xml = rfsanXml.ToString();
TransactionScope.SaveXml(xml, EDTTransactionXmlDirection.Inbound);
TransactionScope.WriteActivity("XML Document is validating...");
schemaValidationResult = xml.IsValidAgainstSchema(XmlSchema.RegulatorFacilitySubmittalActionNotification);
if (!schemaValidationResult.IsValid)
{
//package is invalid due to schema validation errors, update the transaction status write some info.
//Merge in the schema validation error messages and associate them with the transaction.
TransactionScope.WriteActivity("XML Document is not valid against the schema.");
foreach (var error in schemaValidationResult.Errors)
{
TransactionScope.WriteMessage("Schema Validation Error: " + error, EDTTransactionMessageType.Error);
}
TransactionScope.WriteMessage("XML document does not validate against the schema.", EDTTransactionMessageType.Error);
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
else
{
TransactionScope.WriteActivity("XML Document is valid against the schema.");
//deserialize the XML into an object graph package.
var package = serializer.Deserialize(rfsanXml);
TransactionScope.SetEDTClientKey(package.RegulatorTransactionKey);
int totalErrorCount = 0;
int errorCount = 0;
//lets analyze and process each one.
foreach (var se in package.Packets)
{
errorCount = 0;
var targetSE = Repository.FacilitySubmittalElements.FindByKey(se.CERSUniqueKey.Value);
if (targetSE != null)
{
//verify the CERSID from the XML matches the FSE
if (targetSE.CERSID != se.CERSID.Value)
{
errorCount++;
TransactionScope.WriteMessage("Facility Submittal Element with CERSUniqueKey '" + se.CERSUniqueKey.Value.ToString() + "' does not belong to CERSID '" + se.CERSID.Value + "'.", EDTTransactionMessageType.Error);
}
//Verify the SubmittalElementID from the XML matches the FSE
if (targetSE.SubmittalElementID != (int)se.SubmittalElement.Value)
{
errorCount++;
TransactionScope.WriteMessage("Facility Submittal Element with CERSUniqueKey '" + se.CERSUniqueKey.Value.ToString() + "' is not a Submittal Element of type '" + (int)se.SubmittalElement.Value + "'.", EDTTransactionMessageType.Error);
}
if (targetSE.SubmittalActionDateTime.HasValue)
{
//verify the SubmittalActionDateTime on the existing FSE is prior to the SubmittalActionDateTime on the targetFSE (from XML)
if (se.ActionOn.Value < targetSE.SubmittalActionDateTime.Value)
{
TransactionScope.WriteMessage("The SubmittalActionOn value must be greater than the existing SubmittalActionOn value (" + targetSE.SubmittalActionDateTime.Value.ToString() + ") for Submittal Element with CERSUniqueKey " + se.CERSUniqueKey.Value.ToString() + ".", EDTTransactionMessageType.Error);
}
}
//Get the Facility, and make sure it exists first.
Facility facility = Repository.Facilities.GetByID(targetSE.CERSID);
if (facility != null)
{
//figure out the CUPA.
var CUPARegulator = Repository.Facilities.GetCUPA(facility);
if (CUPARegulator != null)
{
//Ensure that the Facilities CUPA is associated with the CUPA calling this processor.
if (contextRegulator.ID != CUPARegulator.ID)
{
errorCount++;
TransactionScope.WriteMessage("Facility Submittal Element with CERSUniqueKey '" + se.CERSUniqueKey.Value.ToString() + "' is assigned to a CUPA the current account is not authorized to submit for.", EDTTransactionMessageType.Error);
}
}
else
{
errorCount++;
TransactionScope.WriteMessage("Cannot identify the CUPA for the Facility Submittal Element with CERSUniqueKey '" + se.CERSUniqueKey.Value.ToString() + "'.", EDTTransactionMessageType.Error);
}
}
else
{
errorCount++;
TransactionScope.WriteMessage("A facility with CERSID '" + targetSE.CERSID + "' cannot be found and therefore Facility Submittal Element with CERSUniqueKey '" + se.CERSUniqueKey.Value.ToString() + "' cannot be updated/found.", EDTTransactionMessageType.Error);
}
//Get the regulator that is described in the XML as the Regulating body that is changing the submittal action information.
var regulator = Repository.Regulators.GetByEDTIdentityKey(se.RegulatorCode.Value);
if (regulator != null)
{
se.TargetRegulator = regulator;
}
else
{
errorCount++;
TransactionScope.WriteMessage("Facility Submittal Element with CERSUniqueKey '" + se.CERSUniqueKey.Value.ToString() + "' specifies '" + se.RegulatorCode.Value + "' for the RegulatorCode element which is not valid.", EDTTransactionMessageType.Error);
}
//make sure that NextDueDate is in the future.
if (se.NextDueDate != null)
{
if (se.NextDueDate.Value < DateTime.Now)
{
errorCount++;
TransactionScope.WriteMessage("Facility Submittal Element with CERSUniqueKey '" + se.CERSUniqueKey.Value.ToString() + "' has a NextDueDate of '" + se.NextDueDate.Value + "' which occurs in the past and is not allowed.", EDTTransactionMessageType.Error);
}
}
}
else
{
errorCount++;
TransactionScope.WriteMessage("Facility Submittal Element with CERSUniqueKey '" + se.CERSUniqueKey.Value.ToString() + "' was not found.", EDTTransactionMessageType.Error);
}
if (errorCount == 0)
{
se.FacilitySubmittalElement = targetSE;
}
totalErrorCount += errorCount;
}
if (totalErrorCount > 0)
{
TransactionScope.WriteActivity("Found " + totalErrorCount + " total error(s) with package. Setting to Rejected.");
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
else
{
try
{
FacilitySubmittalElement fse = null;
//all is good, so lets update them all and process it.
foreach (var se in package.Packets)
{
fse = se.FacilitySubmittalElement;
if (fse != null)
{
ServiceManager.BusinessLogic.SubmittalElements.UpdateFacilitySubmittalElementStatus
(
fse,
se.Status.Value,
se.ActionOn,
se.Comments,
se.NextDueDate,
Repository.ContextAccount,
se.TargetRegulator.ID,
se.AgentName,
se.AgentEmail,
submittalActionEDTTransaction: TransactionScope.Transaction
);
TransactionScope.Connect(fse);
}
}
TransactionScope.WriteActivity("All Facility Submittal Elements (" + package.Packets + ") updated successfully.");
TransactionScope.SetStatus(EDTTransactionStatus.Accepted);
TransactionScope.SetProcessedOn();
}
catch (Exception ex)
{
TransactionScope.WriteActivity("Errors occurred persisting updates to database.", ex);
TransactionScope.Complete(EDTTransactionStatus.ErrorProcessing);
}
}
}
}
else
{
TransactionScope.WriteMessage("No package received.", EDTTransactionMessageType.Error);
TransactionScope.Complete(EDTTransactionStatus.ErrorProcessing);
}
XElement responseXml = responseSerializer.PreparePackage(TransactionScope.Transaction);
responseSerializer.AddTransaction(responseXml, TransactionScope.Transaction);
responseSerializer.AddSummary(responseXml, TransactionScope.Transaction);
TransactionScope.SaveXml(responseXml, EDTTransactionXmlDirection.Outbound);
return(responseXml);
}
public XElement Process(Stream stream, int regulatorCode)
{
RegulatorFacilityMetadataResponseXmlSerializer responseSerializer = new RegulatorFacilityMetadataResponseXmlSerializer(Repository);
Regulator regulator = Repository.Regulators.GetByEDTIdentityKey(regulatorCode);
if (regulator == null)
{
throw new ArgumentException("RegulatorCode does not contain a valid number.", "regulatorCode");
}
TransactionScope.Connect(regulator);
//declare the package to be use to inflate the XML.
RegulatorXmlObjectPacket <RegulatorFacilityMetadataPackage> package = null;
XmlSchemaValidationResult schemaValidationResult = null;
var rfmXml = ConvertStreamToXDocument(stream);
if (rfmXml != null)
{
string xml = rfmXml.ToString();
TransactionScope.SaveXml(xml, EDTTransactionXmlDirection.Inbound);
TransactionScope.WriteActivity("XML Document is validating...");
schemaValidationResult = xml.IsValidAgainstSchema(XmlSchema.RegulatorFacilityMetadata);
if (!schemaValidationResult.IsValid)
{
//package is invalid due to schema validation errors, update the transaction status write some info.
//Merge in the schema validation error messages and associate them with the transaction.
TransactionScope.WriteActivity("XML Document is not valid against the schema.");
foreach (var error in schemaValidationResult.Errors)
{
TransactionScope.WriteMessage("Schema Validation Error: " + error, EDTTransactionMessageType.Error);
}
TransactionScope.WriteMessage("XML document does not validate against the schema.", EDTTransactionMessageType.Error);
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
else
{
TransactionScope.WriteActivity("XML Document is valid against the schema.");
//deserialize the data into the object structure.
RegulatorFacilityMetadataXmlSerializer serializer = new RegulatorFacilityMetadataXmlSerializer(Repository);
package = serializer.Deserialize(rfmXml);
TransactionScope.SetEDTClientKey(package.RegulatorTransactionKey);
package.Packet.Workspace.Facility = Repository.Facilities.GetByID(package.Packet.CERSID);
if (package.Packet.Workspace.Facility == null)
{
TransactionScope.WriteMessage("There is no facility with CERSID " + package.Packet.CERSID, EDTTransactionMessageType.Error);
package.Packet.Workspace.Messages.Add("There is no facility with CERSID " + package.Packet.CERSID, FacilityOperationMessageType.Error);
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
else
{
//get the original FRSE Mappings
var originalFRSEMappings = GetOriginalFRSEMappings(package.Packet.CERSID);
//merge the XML data into the existing FRSE objects.
ServiceManager.Facilities.MergeFacilityRegulatorSubmittalElementCustomMappings(package.Packet, regulator.ID);
//generate debug messages so we know what happened here.
DetermineFacilityRegulatorSubmittalElementChanges(package, originalFRSEMappings);
//merge the CERS Geo data in XML into the object graph.
ServiceManager.Facilities.MergeCERSFacilityGeoPoint(package.Packet);
//commit the changes to the database.
CommitChanges(package);
//complete the transaction indicating everything went according to plan.
TransactionScope.Complete(EDTTransactionStatus.Accepted);
}
}
}
//prepare our output response XML.
XElement responseXml = responseSerializer.PreparePackage(TransactionScope.Transaction);
responseSerializer.AddTransaction(responseXml, TransactionScope.Transaction);
if (package != null)
{
responseSerializer.AddMessages(responseXml, package.Packet);
}
TransactionScope.SaveXml(responseXml, EDTTransactionXmlDirection.Outbound);
return(responseXml);
}
public virtual XElement Process(Stream stream, int regulatorCode)
{
//contextRegulator is always the regulator this Processor is working under the context of. In this case, the assumption is, this Regulator is
//ALWAYS a CUPA.
Regulator contextRegulator = Repository.Regulators.GetByEDTIdentityKey(regulatorCode);
if (contextRegulator == null)
{
throw new ArgumentException("RegulatorCode does not contain a valid number.", "regulatorCode");
}
TransactionScope.Connect(contextRegulator);
ZipFile zipFile = null;
XDocument rfsXml = null;
if (IsZipPackage(stream))
{
//get the zip file.
zipFile = ZipFile.Read(stream);
if (ValidateZip(zipFile))
{
TransactionScope.WriteActivity("The ZipFile passed validation.");
//so now that we have validated the zip file's package integrity, lets pull the XML file out
//zipFile = ZipFile.Read(stream);
rfsXml = ExtractXmlFile(zipFile);
}
else
{
TransactionScope.WriteActivity("The ZipFile failed validation.");
TransactionScope.WriteMessage("The ZipFile failed validation.", EDTTransactionMessageType.Error);
TransactionScope.SetStatus(EDTTransactionStatus.Rejected);
}
}
else
{
//there is no Zip File, so convert the Stream to XML.
rfsXml = ConvertStreamToXDocument(stream);
}
if (rfsXml != null)
{
TransactionScope.SaveXml(rfsXml, EDTTransactionXmlDirection.Inbound);
}
try
{
if (rfsXml != null && ValidateXml(rfsXml, XmlSchema.RegulatorFacilitySubmittal))
{
//at this point, at the high level the package appears to be good, so lets deserialize it, this part sucks...
//call the Serializer for this type of schema that will deserialize the XML into object graphs
RegulatorFacilitySubmittalXmlSerializer serializer = new RegulatorFacilitySubmittalXmlSerializer(Repository);
var package = serializer.Deserialize(rfsXml, zipFile);
if (VerifyPackageRules(package))
{
TransactionScope.SetEDTClientKey(package.RegulatorTransactionKey);
if (ValidateCommitPackage(package))
{
// queue up submittal deltas for submitted FSE's
if (package.Packets != null)
{
foreach (RegulatorFacilitySubmittalPacket packet in package.Packets)
{
var submittedSubmittalElements = (from sp in packet.FacilitySubmittalElementPackets select sp.FacilitySubmittalElement).ToList();
ServiceLocator.GetSystemServiceManager(Repository).SubmittalDelta.QueueDeltaFSEs(submittedSubmittalElements);
}
}
TransactionScope.Complete(EDTTransactionStatus.Accepted);
}
else
{
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
}
else
{
//package verification failed.
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
}
else
{
//either we didn't get XML or we did but it didn't validate.
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
}
catch (Exception ex)
{
Repository.ClearObjectContextState();
TransactionScope.WriteMessage(ex.Message, EDTTransactionMessageType.Error);
TransactionScope.WriteActivity("An error occurred while attempting to process the XML.", ex, type: EDTTransactionMessageType.Error);
TransactionScope.Complete(EDTTransactionStatus.Rejected);
}
var responseXml = PrepareResponsePackage();
TransactionScope.SaveXml(responseXml, EDTTransactionXmlDirection.Outbound);
return(responseXml);
}
protected virtual bool ValidateCommitPackage(RegulatorXmlObjectCollectionPackage <RegulatorFacilitySubmittalPacket> package)
{
if (package == null)
{
throw new ArgumentException("package");
}
bool result = false;
foreach (var fsPacket in package.Packets)
{
ValidateCommitPackage(fsPacket);
}
//see if we have any invalid FacilitySubmittal Packets
int invalidCount = package.Packets.Where(p => !p.IsValid).Count();
//if not, we are good to go to officially say we are ok with this package and flip all the voided to false and update metadata.
if (invalidCount == 0)
{
result = true;
//now we need to go through and trigger all the updates to flip the voided flag on everything.
foreach (var fsPacket in package.Packets)
{
//change voided to false for each and every FacilitySubmittalElement.
foreach (var fsePacket in fsPacket.FacilitySubmittalElementPackets)
{
if (fsePacket.Type == SubmittalElementType.FacilityInformation)
{
//process additional business rules information.
PostProcessFacilityInformationSubmittalElementBusinessLogic(fsePacket.FacilitySubmittalElement);
//If the Facility Information FSE has a Status of "Accepted", call Business Service method to update Facility from Facility Information FSE.
//This ensures that any changes to important Facility data such as Name, Address, FacilityID, EPAID, etc. that are accepted by the Regulator
//get propegated to the Facility table
if (fsePacket.FacilitySubmittalElement.StatusID == (int)SubmittalElementStatus.Accepted)
{
ServiceManager.BusinessLogic.SubmittalElements.FacilityInformation.UpdateFacilityFromFacilityInformation(fsePacket.FacilitySubmittalElement);
}
}
//update voided for FSE and save.
fsePacket.FacilitySubmittalElement.Voided = false;
//save this submittal element.
Repository.FacilitySubmittalElements.Save(fsePacket.FacilitySubmittalElement);
TransactionScope.Connect(fsePacket.FacilitySubmittalElement);
//update FRSE metadata.
ProcessFacilityRegulatorSubmittalElementMetadata(fsPacket.Facility, fsePacket);
UpdateFacilityRegulatorSubmittalElement(fsPacket.Facility, fsePacket);
}
//if we got a FacilitySubmittal lets update it's voided to false as well and update it.
if (fsPacket.FacilitySubmittal != null)
{
fsPacket.FacilitySubmittal.Voided = false;
Repository.FacilitySubmittals.Save(fsPacket.FacilitySubmittal);
}
ServiceManager.Events.CreateFacilitySubmittalNotification(fsPacket.Facility, fsPacket.FacilitySubmittal);
TransactionScope.Connect(fsPacket.FacilitySubmittal);
}
}
return(result);
}
