Beispiel #1
0
        public async Task Handle(T message, IMessageHandlerContext context)
        {
            paymentLogger.LogInfo($"Processing RequiredPaymentsProxyService event. Message Id : {context.MessageId}");
            executionContext.JobId = message.JobId.ToString();

            var contractType = message is PayableEarningEvent ? ContractType.Act1 :
                               message is ApprenticeshipContractType2EarningEvent ? ContractType.Act2 :
                               (message as IFunctionalSkillEarningEvent)?.ContractType
                               ?? throw new InvalidOperationException($"Cannot resolve contract type for {typeof(T).FullName}");

            var key = apprenticeshipKeyService.GenerateApprenticeshipKey(
                message.Ukprn,
                message.Learner.ReferenceNumber,
                message.LearningAim.FrameworkCode,
                message.LearningAim.PathwayCode,
                message.LearningAim.ProgrammeType,
                message.LearningAim.StandardCode,
                message.LearningAim.Reference,
                message.CollectionPeriod.AcademicYear,
                contractType
                );

            var actorId = new ActorId(key);
            var actor   = proxyFactory.CreateActorProxy <IRequiredPaymentsService>(new Uri("fabric:/SFA.DAS.Payments.RequiredPayments.ServiceFabric/RequiredPaymentsServiceActorService"), actorId);
            IReadOnlyCollection <PeriodisedRequiredPaymentEvent> requiredPaymentEvent;

            requiredPaymentEvent = await HandleEarningEvent(message, actor).ConfigureAwait(false);

            if (requiredPaymentEvent != null)
            {
                await Task.WhenAll(requiredPaymentEvent.Select(context.Publish)).ConfigureAwait(false);
            }

            paymentLogger.LogInfo($"Successfully processed RequiredPaymentsProxyService event for Actor Id {actorId}");
        }
Beispiel #2
0
        public async Task Handle(IdentifiedRemovedLearningAim message, IMessageHandlerContext context)
        {
            logger.LogDebug($"Processing 'IdentifiedRemovedLearningAim' message.");
            ((ExecutionContext)executionContext).JobId = message.JobId.ToString();

            var key = apprenticeshipKeyService.GenerateApprenticeshipKey(
                message.Ukprn,
                message.Learner.ReferenceNumber,
                message.LearningAim.FrameworkCode,
                message.LearningAim.PathwayCode,
                message.LearningAim.ProgrammeType,
                message.LearningAim.StandardCode,
                message.LearningAim.Reference,
                message.CollectionPeriod.AcademicYear,
                message.ContractType);

            var actorId = new ActorId(key);
            var actor   = proxyFactory.CreateActorProxy <IRequiredPaymentsService>(new Uri("fabric:/SFA.DAS.Payments.RequiredPayments.ServiceFabric/RequiredPaymentsServiceActorService"), actorId);
            IReadOnlyCollection <PeriodisedRequiredPaymentEvent> requiredPayments = await actor.RefundRemovedLearningAim(message, CancellationToken.None).ConfigureAwait(false);

            logger.LogDebug($"Got {requiredPayments?.Count ?? 0} required payments.");
            if (requiredPayments != null)
            {
                await Task.WhenAll(requiredPayments.Select(context.Publish)).ConfigureAwait(false);
            }
            logger.LogInfo($"Successfully processed IdentifiedRemovedLearningAim event for Actor Id {actorId}");
        }
Beispiel #3
0
        public async Task Handle(T message, IMessageHandlerContext context)
        {
            paymentLogger.LogInfo($"Processing RequiredPaymentsProxyService event. Message Id : {context.MessageId}");
            executionContext.JobId = message.JobId.ToString();

            var contractType = GetContractTypeFromMessage(message);

            var key = apprenticeshipKeyService.GenerateApprenticeshipKey(
                message.Ukprn,
                message.Learner.ReferenceNumber,
                message.LearningAim.FrameworkCode,
                message.LearningAim.PathwayCode,
                message.LearningAim.ProgrammeType,
                message.LearningAim.StandardCode,
                message.LearningAim.Reference,
                message.CollectionPeriod.AcademicYear,
                contractType
                );

            var actorId = new ActorId(key);
            var actor   = proxyFactory.CreateActorProxy <IRequiredPaymentsService>(
                new Uri("fabric:/SFA.DAS.Payments.RequiredPayments.ServiceFabric/RequiredPaymentsServiceActorService"),
                actorId);
            IReadOnlyCollection <PeriodisedRequiredPaymentEvent> requiredPaymentEvent;

            requiredPaymentEvent = await HandleEarningEvent(message, actor).ConfigureAwait(false);

            if (requiredPaymentEvent != null)
            {
                await Task.WhenAll(requiredPaymentEvent.Select(context.Publish)).ConfigureAwait(false);
            }

            paymentLogger.LogInfo("Successfully processed RequiredPaymentsProxyService event for Actor for " +
                                  $"jobId:{message.JobId}, learnerRef:{message.Learner.ReferenceNumber}, frameworkCode:{message.LearningAim.FrameworkCode}, " +
                                  $"pathwayCode:{message.LearningAim.PathwayCode}, programmeType:{message.LearningAim.ProgrammeType}, " +
                                  $"standardCode:{message.LearningAim.StandardCode}, learningAimReference:{message.LearningAim.Reference}, " +
                                  $"academicYear:{message.CollectionPeriod.AcademicYear}, contractType:{contractType}");
        }