public async Task TestRegistrations()
        {
            try
            {
                JobContextMessage jobContextMessage =
                    new JobContextMessage(
                        1,
                        new ITopicItem[] { new TopicItem("SubscriptionName", new List <ITaskItem>()) },
                        0,
                        DateTime.UtcNow);
                jobContextMessage.KeyValuePairs[JobContextMessageKey.Container] = "Container";
                CancellationTokenSource cts = new CancellationTokenSource();
                cts.Cancel();

                ContainerBuilder containerBuilder = DIComposition.BuildContainer(new TestConfigurationHelper());

                IContainer c = containerBuilder.Build();
                using (var lifeTime = c.BeginLifetimeScope())
                {
                    var  messageHandler = lifeTime.Resolve <IMessageHandler <JobContextMessage> >();
                    bool ret            = await messageHandler.HandleAsync(jobContextMessage, cts.Token);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                Assert.Null(ex);
            }
        }
示例#2
0
        public async Task TestRegistrations()
        {
            CancellationTokenSource cts = new CancellationTokenSource();

            cts.Cancel();

            ContainerBuilder containerBuilder = DIComposition.BuildContainer(new TestConfigurationHelper());

            IContainer c;

            try
            {
                RegisterYearSpecificServices(containerBuilder);
                c = containerBuilder.Build();

                using (var lifeTime = c.BeginLifetimeScope())
                {
                    var messageHandler       = lifeTime.Resolve <IJobContextManager <JobContextMessage> >();
                    var serviceController    = lifeTime.Resolve <IServiceController>();
                    var storageController    = lifeTime.Resolve <IStorageController>();
                    var validationController = lifeTime.Resolve <IValidationController>();
                    var reportingController  = lifeTime.Resolve <IReportingController>();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
示例#3
0
        public void TestServicesRegisteredByCollectionName(string collectionName, Type serviceType, bool expectation)
        {
            ContainerBuilder cb = DIComposition.BuildContainer(new TestConfigurationHelper());

            DIComposition.RegisterServicesByCollectionName(collectionName, cb);
            var container = cb.Build();

            container.Resolve <IFM36ProviderService>().GetType()?.Equals(serviceType).Should().Be(expectation);
        }
示例#4
0
        public void TestRegistrations()
        {
            ContainerBuilder containerBuilder = DIComposition.BuildContainer(new TestConfigurationHelper());

            var c = containerBuilder.Build();

            using (var lifeTime = c.BeginLifetimeScope())
            {
                var messageHandler = lifeTime.Resolve <IMessageHandler <JobContextMessage> >();
                var entryPoint     = lifeTime.Resolve <IEntryPoint>();

                entryPoint.Should().NotBeNull();

                messageHandler.Should().NotBeNull();
            }
        }
        [InlineData("EASDATA-10003909-20200816-100004.csv", 10003909, 62, 1508)] // all combinations

        public async Task ProcessEASFile(string filename, int ukPrn, int expectedSubmissionValuesCount, int expectedValidationErrorsCount)
        {
            var connString = ConfigurationManager.AppSettings["EasdbConnectionString"];
            DbContextOptions <EasContext> options = new DbContextOptionsBuilder <EasContext>().UseSqlServer(connString).UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking).Options;
            EasContext easdbContext = new EasContext(options);
            List <EasSubmissionValue> easSubmissionValues = new List <EasSubmissionValue>();
            List <ValidationError>    validationErrors    = new List <ValidationError>();
            var easContextMessage = BuildEasJobContextMessage(filename, ukPrn, 0);
            var builder           = new ContainerBuilder();

            _output.WriteLine(connString);
            CleanUp(ukPrn.ToString(), easdbContext);
            DIComposition.RegisterTypes(builder);
            var container = builder.Build();

            EntryPoint entryPoint = new EntryPoint(
                new SeriLogger(new ApplicationLoggerSettings(), new Logging.ExecutionContext(), null),
                container.Resolve <IValidationService>(),
                container.Resolve <IReportingController>());


            var tasks = container.Resolve <IList <IEasServiceTask> >();

            var result = await entryPoint.CallbackAsync(easContextMessage, CancellationToken.None, tasks);

            var easSubmission = easdbContext.EasSubmissions.FirstOrDefault(x => x.Ukprn == ukPrn.ToString());

            if (easSubmission != null)
            {
                easSubmissionValues = easdbContext.EasSubmissionValues.Where(x => x.SubmissionId == easSubmission.SubmissionId).ToList();
            }

            var sourceFile = easdbContext.SourceFiles.FirstOrDefault(x => x.Ukprn == ukPrn.ToString());

            if (sourceFile != null)
            {
                validationErrors = easdbContext.ValidationErrors.Where(x => x.SourceFileId == sourceFile.SourceFileId).ToList();
            }

            Assert.Equal(expectedSubmissionValuesCount, easSubmissionValues.Count);
            Assert.Equal(expectedValidationErrorsCount, validationErrors.Count);
        }
        public void TestRegistrations()
        {
            ContainerBuilder       builder           = DIComposition.BuildNewContainer();
            ConfigurationRootModel configurationRoot = DICompositionServiceFabric.BuildContainer(builder, new TestConfigurationHelper());

            DIComposition.BuildContainer(builder, configurationRoot);
            DIComposition.RegisterServicesByYear(Constants.YEAR_1920, builder);
            DIComposition.BuildStorageContainerAzure(builder, configurationRoot.azureBlobStorageOptions);

            var c = builder.Build();

            using (var lifeTime = c.BeginLifetimeScope())
            {
                var messageHandler = lifeTime.Resolve <IMessageHandler <JobContextMessage> >();
                var entryPoint     = lifeTime.Resolve <EntryPoint>();

                entryPoint.Should().NotBeNull();

                messageHandler.Should().NotBeNull();
            }
        }
        public static void Main(string[] args)
        {
            var configurationBuilder = new ConfigurationBuilder()
                                       .SetBasePath(Directory.GetCurrentDirectory())
                                       .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

            IConfigurationRoot configuration = configurationBuilder.Build();

            // License Aspose.Cells
            string asposeLicense = configuration["AsposeLicence"];

            if (!string.IsNullOrEmpty(asposeLicense))
            {
                using (MemoryStream ms =
                           new MemoryStream(Encoding.UTF8.GetBytes(asposeLicense.Replace("&lt;", "<").Replace("&gt;", ">"))))
                {
                    new License().SetLicense(ms);
                }
            }

            // Setup Autofac
            ContainerBuilder       builder           = DIComposition.BuildNewContainer();
            ConfigurationRootModel configurationRoot = new ConfigurationRootModel
            {
                azureBlobStorageOptions = new AzureStorageOptions
                {
                    AzureBlobConnectionString = configuration["AzureBlobConnectionString"],
                    AzureBlobContainerName    = configuration["AzureBlobContainerName"]
                },
                reportServiceConfiguration = new ReportServiceConfiguration
                {
                    DASPaymentsConnectionString      = configuration["DASPaymentsConnectionString"],
                    ILR1920DataStoreConnectionString = configuration["ILR1920DataStoreConnectionString"],
                    ILR2021DataStoreConnectionString = configuration["ILR2021DataStoreConnectionString"],
                },
                versionInfo = new VersionInfo
                {
                    ServiceReleaseVersion = "1.0"
                }
            };

            DIComposition.BuildContainer(builder, configurationRoot);
            DIComposition.BuildStorageFileSystem(builder, configurationRoot.azureBlobStorageOptions,
                                                 new FileSystemService(@"C:\Temp\"));

            IReportServiceContext reportServiceContext = new ConsoleReportServiceContext
            {
                JobId                 = -1,
                Container             = configurationRoot.azureBlobStorageOptions.AzureBlobContainerName,
                CollectionYear        = "1920",
                CollectionName        = "PE-DAS-AppsInternalDataMatchMonthEndReport1920",
                ReturnPeriod          = 3,
                ILRPeriods            = GetIlrPeriods(),
                IsIlrSubmission       = false,
                SubmissionDateTimeUtc = DateTime.UtcNow,
                Tasks                 = new List <string>
                {
                    ReportTaskNameConstants.InternalDataMatchReport
                },
                Ukprn = 0
            };

            builder.Register(c => new ApplicationLoggerSettings
            {
                ApplicationLoggerOutputSettingsCollection = new List <IApplicationLoggerOutputSettings>
                {
                    new ConsoleApplicationLoggerOutputSettings
                    {
                        MinimumLogLevel = LogLevel.Verbose
                    }
                } as IList <IApplicationLoggerOutputSettings>
            }).As <IApplicationLoggerSettings>().SingleInstance();
            builder.RegisterType <ExecutionContext>().As <IExecutionContext>().InstancePerLifetimeScope();
            builder.RegisterType <SerilogLoggerFactory>().As <ISerilogLoggerFactory>().InstancePerLifetimeScope();
            builder.RegisterType <SeriLogger>().As <ILogger>().InstancePerLifetimeScope();

            using (var container = builder.Build())
            {
                IHandler handler = container.Resolve <IHandler>();
                bool     res     = handler.HandleAsync(reportServiceContext, CancellationToken.None).Result;
                System.Console.WriteLine($"Finished - {res}");
            }
        }