public async Task <ImportMovement> Create(Guid notificationId, int number, DateTime actualShipmentDate, DateTime?prenotificationDate)
{
if (!await numberValidator.Validate(notificationId, number))
{
throw new MovementNumberException("Cannot create an import movement with a conflicting movement number (" + number + ") for import notification: " + notificationId);
}
var notificationStatus = (await assessmentRepository.GetByNotification(notificationId)).Status;
if (notificationStatus != ImportNotificationStatus.Consented)
{
throw new InvalidOperationException(
string.Format("Cannot create a movement for notification {0} because its status is {1}",
notificationId, notificationStatus));
}
if (prenotificationDate.HasValue)
{
if (prenotificationDate > SystemTime.UtcNow.Date)
{
throw new InvalidOperationException("The prenotification date cannot be in the future.");
}
if (actualShipmentDate < prenotificationDate)
{
throw new InvalidOperationException("The actual date of shipment cannot be before the prenotification date.");
}
if (actualShipmentDate > prenotificationDate.Value.AddDays(60))
{
throw new InvalidOperationException("The actual date of shipment should not be more than 30 calendar days after the prenotification date.");
}
}
return(new ImportMovement(notificationId, number, actualShipmentDate));
}
public async Task <Unit> HandleAsync(SetNotificationFileClosedDate message)
{
var assessment = await repository.GetByNotification(message.ImportNotificationId);
assessment.MarkFileClosed(message.Date);
await context.SaveChangesAsync();
return(Unit.Value);
}
public async Task <Unit> HandleAsync(SetArchiveReference message)
{
var assessment = await repository.GetByNotification(message.NotificationId);
assessment.SetArchiveReference(message.ArchiveReference);
await context.SaveChangesAsync();
return(Unit.Value);
}
public async Task <ImportWithdrawn> Withdraw(Guid importNotificationId, DateTime date, string reasons)
{
var assessment = await assessmentRepository.GetByNotification(importNotificationId);
var withdrawal = assessment.Withdraw(date, reasons);
withdrawnRepository.Add(withdrawal);
return(withdrawal);
}
public async Task <bool> HandleAsync(SetNotificationCompletedDate message)
{
var assessment = await repository.GetByNotification(message.ImportNotificationId);
assessment.CompleteNotification(message.Date);
await context.SaveChangesAsync();
return(true);
}
public async Task <KeyDatesOverrideData> HandleAsync(GetImportKeyDatesOverrideData message)
{
var assessment = await assessmentRepository.GetByNotification(message.NotificationId);
var keyDates = await repository.GetKeyDatesForNotification(message.NotificationId);
keyDates.DecisionRequiredByDate = await decisionRequiredBy.GetDecisionRequiredByDate(assessment);
return(keyDates);
}
public async Task <bool> HandleAsync(SetAssessmentStartedDate message)
{
var assessment = await assessmentRepository.GetByNotification(message.ImportNotificationId);
assessment.BeginAssessment(message.Date, message.NameOfOfficer);
await context.SaveChangesAsync();
return(true);
}
public async Task <bool> HandleAsync(WithdrawConsentForImportNotification message)
{
var assessment = await repository.GetByNotification(message.Id);
assessment.WithdrawConsent(message.Date, message.ReasonsForConsentWithdrawal);
await context.SaveChangesAsync();
return(true);
}
public async Task <ImportObjection> Object(Guid notificationId, DateTime date, string reasons)
{
var assessment = await assessmentRepository.GetByNotification(notificationId);
var objection = assessment.Object(date, reasons);
objectionRepository.Add(objection);
return(objection);
}
public async Task Consent(Guid notificationId,
DateRange dateRange,
string conditions,
DateTime consentedDate)
{
var assessment = await assessmentRepository.GetByNotification(notificationId);
var consent = assessment.Consent(dateRange, conditions, userContext.UserId, consentedDate);
consentRepository.Add(consent);
}
public async Task <bool> HandleAsync(CompleteDraftImportNotification message)
{
var draft = await draftImportNotificationRepository.Get(message.ImportNotificationId);
var assessment =
await importNotificationAssessmentRepository.GetByNotification(message.ImportNotificationId);
var result = await importNotificationValidator.ValidateAsync(draft);
if (result.IsValid && assessment.Status == ImportNotificationStatus.NotificationReceived)
{
var notification =
await importNotificationRepository.Get(message.ImportNotificationId);
var exporter = mapper.Map <Exporter>(draft.Exporter);
var facilityCollection = mapper.Map <FacilityCollection>(draft.Facilities, draft.Preconsented);
var importer = mapper.Map <Importer>(draft.Importer);
var producer = mapper.Map <Producer>(draft.Producer);
var shipment = mapper.Map <Shipment>(draft.Shipment, draft.Preconsented);
var transportRoute = new Domain.ImportNotification.TransportRoute(message.ImportNotificationId,
mapper.Map <StateOfExport>(draft.StateOfExport),
mapper.Map <StateOfImport>(draft.StateOfImport));
if (!draft.TransitStates.HasNoTransitStates)
{
transportRoute.SetTransitStates(
new TransitStateList(draft.TransitStates.TransitStates.Select(t => mapper.Map <TransitState>(t))));
}
var wasteOperation = mapper.Map <WasteOperation>(draft.WasteOperation, notification);
var wasteType = mapper.Map <Domain.ImportNotification.WasteType>(draft.WasteType, draft.ChemicalComposition.Composition);
exporterRepository.Add(exporter);
facilityRepository.Add(facilityCollection);
importerRepository.Add(importer);
producerRepository.Add(producer);
shipmentRepository.Add(shipment);
transportRouteRepository.Add(transportRoute);
wasteOperationRepository.Add(wasteOperation);
wasteTypeRepository.Add(wasteType);
assessment.Submit();
await context.SaveChangesAsync();
}
return(result.IsValid);
}
public async Task <Unit> HandleAsync(SetImportKeyDatesOverride message)
{
var assessment = await assessmentRepository.GetByNotification(message.Data.NotificationId);
var currentDecisionRequiredByDate = await decisionRequiredBy.GetDecisionRequiredByDate(assessment);
if (currentDecisionRequiredByDate != message.Data.DecisionRequiredByDate)
{
await repository.SetDecisionRequiredByDateForNotification(assessment.Id, message.Data.DecisionRequiredByDate);
}
await repository.SetKeyDatesForNotification(message.Data);
return(Unit.Value);
}
public async Task <ImportNotificationAssessmentDecisionData> HandleAsync(GetImportNotificationAssessmentDecisionData message)
{
var facilityCollection = await facilityRepository.GetByNotificationId(message.ImportNotificationId);
var isPreconsented = facilityCollection == null ? (bool?)null : facilityCollection.AllFacilitiesPreconsented;
var assessment = await assessmentRepository.GetByNotification(message.ImportNotificationId);
return(new ImportNotificationAssessmentDecisionData
{
Status = assessment.Status,
AvailableDecisions = assessment.GetAvailableDecisions().ToArray(),
AcknowledgedOnDate = assessment.Dates.AcknowledgedDate.GetValueOrDefault(),
IsPreconsented = isPreconsented,
NotificationReceivedDate = assessment.Dates.NotificationReceivedDate.GetValueOrDefault()
});
}
public ImportMovementFactoryTests()
{
assessmentRepository = A.Fake<IImportNotificationAssessmentRepository>();
validator = A.Fake<IImportMovementNumberValidator>();
A.CallTo(() => validator.Validate(notificationId, A<int>.Ignored))
.Returns(true);
assessment = new ImportNotificationAssessment(notificationId);
ObjectInstantiator<ImportNotificationAssessment>.SetProperty(x => x.Status,
ImportNotificationStatus.Consented, assessment);
A.CallTo(() => assessmentRepository.GetByNotification(notificationId))
.Returns(assessment);
factory = new ImportMovementFactory(validator, assessmentRepository);
}
public async Task <AccountOverviewData> HandleAsync(GetImportNotificationAccountOverview message)
{
var assessment = await notificationAssessmentRepository.GetByNotification(message.ImportNotificationId);
var charge = await chargeCalculator.GetValue(message.ImportNotificationId);
var transactions = await transactionRepository.GetTransactions(message.ImportNotificationId);
var totalPaid = await transactionCalculator.TotalPaid(message.ImportNotificationId);
return(new AccountOverviewData
{
TotalCharge = charge,
TotalPaid = totalPaid,
Transactions = transactions.Select(t => mapper.Map <TransactionRecordData>(t)).ToArray(),
PaymentReceived = assessment.Dates.PaymentReceivedDate
});
}
public ImportMovementFactoryTests()
{
SystemTime.Freeze(Today);
assessmentRepository = A.Fake <IImportNotificationAssessmentRepository>();
validator = A.Fake <IImportMovementNumberValidator>();
A.CallTo(() => validator.Validate(notificationId, A <int> .Ignored))
.Returns(true);
assessment = new ImportNotificationAssessment(notificationId);
ObjectInstantiator <ImportNotificationAssessment> .SetProperty(x => x.Status,
ImportNotificationStatus.Consented, assessment);
A.CallTo(() => assessmentRepository.GetByNotification(notificationId))
.Returns(assessment);
factory = new ImportMovementFactory(validator, assessmentRepository);
}
public ImportPaymentTransactionTests()
{
importNotificationTransactionRepository = A.Fake <IImportNotificationTransactionRepository>();
importNotificationTransactionCalculator = A.Fake <IImportNotificationTransactionCalculator>();
importNotificationAssessmentRepository = A.Fake <IImportNotificationAssessmentRepository>();
assessment = new ImportNotificationAssessment(notificationId);
A.CallTo(() => importNotificationAssessmentRepository.GetByNotification(notificationId))
.Returns(assessment);
A.CallTo(() => importNotificationTransactionCalculator.Balance(notificationId))
.Returns(1000);
transaction = new ImportPaymentTransaction(
importNotificationTransactionRepository,
importNotificationTransactionCalculator,
importNotificationAssessmentRepository);
}
public async Task <KeyDatesData> HandleAsync(GetKeyDates message)
{
var notification = await notificationRepository.Get(message.ImportNotificationId);
var consultation = await consultationRepository.GetByNotificationId(message.ImportNotificationId);
var assessment = await notificationAssessmentRepository.GetByNotification(message.ImportNotificationId);
var interimStatus = await interimStatusRepository.GetByNotificationId(message.ImportNotificationId);
var decisions = await notificationAssessmentDecisionRepository.GetByImportNotificationId(message.ImportNotificationId);
var paymentReceived = await transactionCalculator.PaymentReceivedDate(message.ImportNotificationId) ??
await transactionCalculator.LatestPayment(message.ImportNotificationId);
DateTime?paymentReceivedDate = null;
if (paymentReceived != null)
{
paymentReceivedDate = paymentReceived.Date;
}
return(new KeyDatesData
{
NotificationReceived = assessment.Dates.NotificationReceivedDate,
PaymentReceived = paymentReceivedDate,
IsPaymentComplete = assessment.Dates.PaymentReceivedDate.HasValue &&
await transactionCalculator.PaymentIsNowFullyReceived(message.ImportNotificationId, 0),
NameOfOfficer = assessment.Dates.NameOfOfficer,
AssessmentStarted = assessment.Dates.AssessmentStartedDate,
NotificationCompletedDate = assessment.Dates.NotificationCompletedDate,
AcknowlegedDate = assessment.Dates.AcknowledgedDate,
DecisionRequiredByDate = await decisionRequiredBy.GetDecisionRequiredByDate(assessment),
IsInterim = interimStatus.IsInterim,
FileClosedDate = assessment.Dates.FileClosedDate,
ArchiveReference = assessment.Dates.ArchiveReference,
DecisionHistory = decisions ?? new List <NotificationAssessmentDecision>(),
CompententAuthority = notification.CompetentAuthority,
IsLocalAreaSet = consultation != null && consultation.LocalAreaId.HasValue,
Status = assessment.Status
});
}
public async Task <Guid> HandleAsync(CreateImportNotification message)
{
var user = await internalUserRepository.GetByUserId(userContext.UserId);
var notification = new ImportNotification(message.NotificationType, user.CompetentAuthority, message.Number);
await importNotificationRepository.Add(notification);
await context.SaveChangesAsync();
var assessment = await assessmentRepository.GetByNotification(notification.Id);
assessment.Receive(message.ReceivedDate);
interimStatusRepository.Add(new InterimStatus(notification.Id, message.IsInterim));
await context.SaveChangesAsync();
return(notification.Id);
}
public async Task <NotificationInfo> HandleAsync(GetNotificationInfo message)
{
var id = await notificationApplicationRepository.GetIdOrDefault(message.Number);
var importId = await importNotificationRepository.GetIdOrDefault(message.Number);
if (!id.HasValue && !importId.HasValue)
{
return(new NotificationInfo
{
IsExistingNotification = false
});
}
if (id.HasValue)
{
var notificationAssessment = await notificationAssessmentRepository.GetByNotificationId(id.Value);
return(new NotificationInfo
{
IsExistingNotification = true,
Id = id.Value,
ExportNotificationStatus = notificationAssessment.Status,
TradeDirection = TradeDirection.Export
});
}
else
{
var notificationAssessment = await importNotificationAssessmentRepository.GetByNotification(importId.Value);
return(new NotificationInfo
{
IsExistingNotification = true,
Id = importId.Value,
ImportNotificationStatus = notificationAssessment.Status,
TradeDirection = TradeDirection.Import
});
}
}
private async Task UpdatePaymentReceivedDate(DateTime?paymentDate, Guid notificationId)
{
var assessment = await assessmentRepository.GetByNotification(notificationId);
if (paymentDate != null)
{
if (assessment.Status == ImportNotificationStatus.AwaitingPayment)
{
assessment.PaymentComplete(paymentDate.GetValueOrDefault());
}
else
{
assessment.Dates.PaymentReceivedDate = paymentDate;
}
}
else
{
if (assessment.Dates.PaymentReceivedDate.HasValue)
{
assessment.Dates.PaymentReceivedDate = null;
}
}
}
public ImportRefundTransactionTests()
{
transactionRepository = A.Fake <IImportNotificationTransactionRepository>();
transactionCalculator = A.Fake <IImportNotificationTransactionCalculator>();
assessmentRepository = A.Fake <IImportNotificationAssessmentRepository>();
refundTransaction = new ImportRefundTransaction(transactionRepository, transactionCalculator, assessmentRepository);
notificationId = new Guid("DB476D01-2870-4322-8284-520B34D9667B");
A.CallTo(() => transactionCalculator.TotalPaid(notificationId)).Returns(100);
A.CallTo(() => transactionRepository.GetTransactions(notificationId))
.Returns(new[]
{
ImportNotificationTransaction.PaymentRecord(notificationId, new DateTime(2015, 12, 1), 100,
PaymentMethod.Cheque, "12345", "comments"),
});
var assessment = new ImportNotificationAssessment(notificationId);
A.CallTo(() => assessmentRepository.GetByNotification(notificationId))
.Returns(assessment);
SystemTime.Freeze(new DateTime(2016, 1, 1));
}