public async Task <IEnumerable <ProducerSubmission> > GenerateProducers(ProcessXmlFile messageXmlFile, MemberUpload memberUpload, Dictionary <string, ProducerCharge> producerCharges)
{
var deserializedXml = xmlConverter.Deserialize <schemeType>(xmlConverter.Convert(messageXmlFile.Data));
var producers = await GenerateProducerData(deserializedXml, memberUpload, producerCharges);
return(producers);
}
public GenerateFromDataReturnXmlResult <T> GenerateDataReturns <T>(ProcessDataReturnXmlFile message) where T : class
{
Guard.ArgumentNotNull(() => message, message);
T deserialisedType = null;
string schemaVersion = "3.35";
// Validate against the schema
var validationErrors = schemaValidator
.Validate(message.Data, @"EA.Weee.Xml.DataReturns.v3schema.xsd", XmlNamespace.DataReturns, schemaVersion)
.ToList();
if (!validationErrors.Any())
{
try
{
deserialisedType = xmlConverter.Deserialize <T>(xmlConverter.Convert(message.Data));
}
catch (XmlDeserializationFailureException e)
{
// Couldn't deserialise - can't go any further, add an error and bail out here
var exceptionMessage = e.InnerException != null ? e.InnerException.Message : e.Message;
var friendlyMessage = errorTranslator.MakeFriendlyErrorMessage(exceptionMessage, schemaVersion);
validationErrors.Add(new XmlValidationError(Core.Shared.ErrorLevel.Error, XmlErrorType.Schema, friendlyMessage));
}
}
return(new GenerateFromDataReturnXmlResult <T>(xmlConverter.XmlToUtf8String(message.Data), deserialisedType, validationErrors));
}
public Dictionary <string, ProducerCharge> Calculate(ProcessXmlFile message)
{
var schemeType = xmlConverter.Deserialize <schemeType>(xmlConverter.Convert(message.Data));
var producerCharges = new Dictionary <string, ProducerCharge>();
var complianceYear = int.Parse(schemeType.complianceYear);
foreach (var producer in schemeType.producerList)
{
var producerName = producer.GetProducerName();
var producerCharge = Task.Run(() => producerChargeCalculator.GetProducerChargeBand(schemeType, producer)).Result;
if (producerCharge != null)
{
if (!producerCharges.ContainsKey(producerName))
{
producerCharges.Add(producerName, producerCharge);
}
else
{
ErrorsAndWarnings.Add(
new MemberUploadError(
ErrorLevel.Error,
UploadErrorType.Business,
string.Format(
"We are unable to check for warnings associated with the charge band of the producer {0} until the duplicate name has been fixed.",
producerName)));
}
}
}
return(producerCharges);
}
private void SetupSchemeTypeComplianceYear()
{
var schemeType = new schemeType()
{
complianceYear = "2019"
};
A.CallTo(() => xmlConverter.Deserialize <schemeType>(A <System.Xml.Linq.XDocument> ._)).Returns(schemeType);
}
public async Task SchemaValidatorHasNoErrors_DeserializationException_ShouldReturnError()
{
A.CallTo(() => schemaValidator.Validate(A <byte[]> ._, string.Empty, A <XNamespace> ._, A <string> ._))
.Returns(new List <XmlValidationError>());
A.CallTo(() => xmlConverter.Deserialize <schemeType>(A <XDocument> ._))
.Throws(new XmlDeserializationFailureException(new Exception("Test exception")));
var result = await XmlValidator().Validate(new ProcessXmlFile(A.Dummy <Guid>(), A.Dummy <byte[]>(), A.Dummy <string>()));
Assert.NotEmpty(result);
Assert.Equal(1, result.Count());
A.CallTo(() => businessValidator.Validate(A <schemeType> ._, A <Guid> ._)).MustNotHaveHappened();
}
public void UpdateCharges()
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
var memberUploads = memberUploadDataAccess.FetchMemberUploadsToProcess();
memberUploadDataAccess.ResetMemberUploadsAnnualCharge(memberUploads);
context.SaveChanges();
foreach (var memberUpload in memberUploads)
{
var message = new ProcessXmlFile(memberUpload.OrganisationId, Encoding.ASCII.GetBytes(memberUpload.RawData.Data), memberUpload.FileName);
var schemeType = xmlConverter.Deserialize <schemeType>(xmlConverter.Convert(message.Data));
var complianceYear = int.Parse(schemeType.complianceYear);
var scheme = context.Schemes.Single(c => c.OrganisationId == message.OrganisationId);
var hasAnnualCharge = totalChargeCalculatorDataAccess.CheckSchemeHasAnnualCharge(scheme, complianceYear, memberUpload.SubmittedDate.Value);
var annualChargedToBeAdded = !hasAnnualCharge && scheme.CompetentAuthority.Abbreviation == UKCompetentAuthorityAbbreviationType.EA;
var total = TotalCalculatedCharges(memberUpload, schemeType, annualChargedToBeAdded, scheme);
Log.Information(string.Format("Member upload {0} updated from {1} to {2}", memberUpload.Id, memberUpload.TotalCharges, total));
memberUploadDataAccess.UpdateMemberUploadAmount(memberUpload, total, annualChargedToBeAdded);
}
dbContextTransaction.Commit();
}
catch (Exception ex)
{
Log.Error(ex.Message + (ex.InnerException != null ? ex.InnerException.Message : string.Empty));
dbContextTransaction.Rollback();
throw;
}
}
}
public async Task <IEnumerable <MemberUploadError> > Validate(ProcessXmlFile message)
{
string schemaVersion = MemberRegistrationSchemaVersion.Version_3_07.GetAttribute <DisplayAttribute>().Name;
// Validate against the schema
var errors = schemaValidator.Validate(message.Data, @"EA.Weee.Xml.MemberRegistration.v3schema.xsd", XmlNamespace.MemberRegistration, schemaVersion)
.Select(e => e.ToMemberUploadError())
.ToList();
if (errors.Any())
{
return(errors);
}
schemeType deserializedXml;
try
{
// Validate deserialized XML against business rules
deserializedXml = xmlConverter.Deserialize <schemeType>(xmlConverter.Convert(message.Data));
}
catch (XmlDeserializationFailureException e)
{
// Couldn't deserialise - can't go any further, add an error and bail out here
var exceptionMessage = e.InnerException != null ? e.InnerException.Message : e.Message;
var friendlyMessage = errorTranslator.MakeFriendlyErrorMessage(exceptionMessage, schemaVersion);
errors.Add(new MemberUploadError(ErrorLevel.Error, UploadErrorType.Schema, friendlyMessage));
return(errors);
}
errors = (await businessValidator.Validate(deserializedXml, message.OrganisationId))
.Select(err => new MemberUploadError(err.ErrorLevel.ToDomainEnumeration <ErrorLevel>(), UploadErrorType.Business, err.Message))
.ToList();
return(errors);
}
public async Task <Guid> HandleAsync(ProcessXmlFile message)
{
authorization.EnsureOrganisationAccess(message.OrganisationId);
// record XML processing start time
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var errors = await xmlValidator.Validate(message);
List <MemberUploadError> memberUploadErrors = errors as List <MemberUploadError> ?? errors.ToList();
bool containsSchemaErrors = memberUploadErrors.Any(e => e.ErrorType == UploadErrorType.Schema);
bool containsErrorOrFatal = memberUploadErrors.Any(e => (e.ErrorLevel == ErrorLevel.Error || e.ErrorLevel == ErrorLevel.Fatal));
Dictionary <string, ProducerCharge> producerCharges = null;
int deserializedcomplianceYear = 0;
decimal?totalChargesCalculated = 0;
var scheme = await context.Schemes.SingleAsync(c => c.OrganisationId == message.OrganisationId);
var annualChargeToBeAdded = false;
if (!containsSchemaErrors || !containsErrorOrFatal)
{
var deserializedXml = xmlConverter.Deserialize <schemeType>(xmlConverter.Convert(message.Data));
deserializedcomplianceYear = int.Parse(deserializedXml.complianceYear);
var hasAnnualCharge = totalChargeCalculatorDataAccess.CheckSchemeHasAnnualCharge(scheme, deserializedcomplianceYear);
if (!hasAnnualCharge)
{
var annualcharge = scheme.CompetentAuthority.AnnualChargeAmount ?? 0;
if (annualcharge > 0 || scheme.CompetentAuthority.Abbreviation == UKCompetentAuthorityAbbreviationType.EA)
{
annualChargeToBeAdded = true;
}
}
producerCharges = totalChargeCalculator.TotalCalculatedCharges(message, scheme, deserializedcomplianceYear, annualChargeToBeAdded, ref totalChargesCalculated);
if (xmlChargeBandCalculator.ErrorsAndWarnings.Any(e => e.ErrorLevel == ErrorLevel.Error) &&
memberUploadErrors.All(e => e.ErrorLevel != ErrorLevel.Error))
{
throw new ApplicationException(String.Format(
"Upload for Organisation '{0}' has no validation errors, but does have producer charge calculation errors which are not currently being enforced",
message.OrganisationId));
}
}
var totalCharges = totalChargesCalculated ?? 0;
var upload = generateFromXml.GenerateMemberUpload(message, memberUploadErrors, totalCharges, scheme, annualChargeToBeAdded);
IEnumerable <ProducerSubmission> producers = Enumerable.Empty <ProducerSubmission>();
//Build producers domain object if there are no errors (schema or business) during validation of xml file.
if (!containsErrorOrFatal)
{
producers = await generateFromXml.GenerateProducers(message, upload, producerCharges);
}
// record XML processing end time
stopwatch.Stop();
upload.SetProcessTime(stopwatch.Elapsed);
context.MemberUploads.Add(upload);
producerSubmissionDataAccess.AddRange(producers);
await context.SaveChangesAsync();
return(upload.Id);
}
