Beispiel #1
0
        public async Task <DateTime?> GetDecisionRequiredByDate(ImportNotificationAssessment notificationAssessment)
        {
            Guard.ArgumentNotNull(() => notificationAssessment, notificationAssessment);

            if (notificationAssessment.Dates.DecisionRequiredByDate != null)
            {
                return(notificationAssessment.Dates.DecisionRequiredByDate);
            }

            if (!notificationAssessment.Dates.AcknowledgedDate.HasValue)
            {
                return(null);
            }

            var notification = await notificationRepository.Get(notificationAssessment.NotificationApplicationId);

            var facilityCollection =
                await facilityRepository.GetByNotificationId(notificationAssessment.NotificationApplicationId);

            return
                (decisionRequiredByCalculator.Get(
                     facilityCollection.AllFacilitiesPreconsented,
                     notificationAssessment.Dates.AcknowledgedDate.Value,
                     notification.CompetentAuthority));
        }
 public static ImportNotificationOverview Load(ImportNotification notification,
     ImportNotificationAssessment assessment,
     Exporter exporter,
     Importer importer,
     Producer producer,
     FacilityCollection facilities,
     Shipment shipment,
     TransportRoute transportRoute,
     WasteOperation wasteOperation,
     WasteType wasteType)
 {
     return new ImportNotificationOverview
     {
         Notification = notification,
         Assessment = assessment,
         Exporter = exporter,
         Importer = importer,
         Producer = producer,
         Facilities = facilities,
         Shipment = shipment,
         TransportRoute = transportRoute,
         WasteOperation = wasteOperation,
         WasteType = wasteType
     };
 }
 public static ImportNotificationOverview Load(ImportNotification notification,
                                               ImportNotificationAssessment assessment,
                                               Exporter exporter,
                                               Importer importer,
                                               Producer producer,
                                               FacilityCollection facilities,
                                               Shipment shipment,
                                               TransportRoute transportRoute,
                                               WasteOperation wasteOperation,
                                               WasteType wasteType)
 {
     return(new ImportNotificationOverview
     {
         Notification = notification,
         Assessment = assessment,
         Exporter = exporter,
         Importer = importer,
         Producer = producer,
         Facilities = facilities,
         Shipment = shipment,
         TransportRoute = transportRoute,
         WasteOperation = wasteOperation,
         WasteType = wasteType
     });
 }
        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);
        }
Beispiel #5
0
        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 async Task<DateTime?> GetDecisionRequiredByDate(ImportNotificationAssessment notificationAssessment)
        {
            Guard.ArgumentNotNull(() => notificationAssessment, notificationAssessment);

            if (!notificationAssessment.Dates.AcknowledgedDate.HasValue)
            {
                return null;
            }

            var notification = await notificationRepository.Get(notificationAssessment.NotificationApplicationId);
            var facilityCollection =
                await facilityRepository.GetByNotificationId(notificationAssessment.NotificationApplicationId);

            return
                decisionRequiredByCalculator.Get(
                    facilityCollection.AllFacilitiesPreconsented,
                    notificationAssessment.Dates.AcknowledgedDate.Value,
                    notification.CompetentAuthority);
        }
        public DecisionRequiredByTests()
        {
            notificationId     = new Guid();
            competentAuthority = UKCompetentAuthority.England;

            decisionRequiredByCalculator = A.Fake <IDecisionRequiredByCalculator>();
            facilityRepository           = A.Fake <IFacilityRepository>();
            importNotificationRepository = A.Fake <IImportNotificationRepository>();
            assessment = new ImportNotificationAssessment(notificationId);

            decisionRequiredBy = new DecisionRequiredBy(importNotificationRepository, facilityRepository, decisionRequiredByCalculator);

            decisionRequiredByDateWhenPopulatedInDB    = new DateTime(2019, 1, 1);
            decisionRequiredByDateWhenNotPopulatedInDB = null;
            acknowledgedDateWhenHasValue   = new DateTime(2019, 2, 2);
            acknowledgedDateWhenHasNoValue = null;
            decisionRequiredByDateWhenAcknowledgeDateHasNoValue = null;
            decisionRequiredByDateWhenCalculated = new DateTime(2019, 3, 3);
        }
        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);
        }
Beispiel #9
0
        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));
        }
 public ImportNotificationAssessmentTests()
 {
     assessment = new ImportNotificationAssessment(Guid.Empty);
 }
 public void Add(ImportNotificationAssessment assessment)
 {
     context.ImportNotificationAssessments.Add(assessment);
 }
 public ImportNotificationAssessmentTests()
 {
     assessment = new ImportNotificationAssessment(Guid.Empty);
 }
Beispiel #13
0
 public void Add(ImportNotificationAssessment assessment)
 {
     context.ImportNotificationAssessments.Add(assessment);
 }