WZC2/be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/TyrpAgentModule.cs

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Polly;
using Volo.Abp;
using Volo.Abp.Account;
using Volo.Abp.Autofac;
using Volo.Abp.AutoMapper;
using Volo.Abp.BackgroundJobs;
using Volo.Abp.BackgroundWorkers;
using Volo.Abp.EntityFrameworkCore;
using Volo.Abp.Http.Client;
using Volo.Abp.Modularity;
using Win_in.Sfs.Auth;
using Win_in.Sfs.Basedata.Application.Contracts;
using Win_in.Sfs.Label.Application.Contracts;
using Win_in.Sfs.Shared.Host;
using Win_in.Sfs.Wms.DataExchange.Dapper.Fawtyg.Tyrp;
using Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Tyrp;
using Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore;
using Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Tyrp;
using Win_in.Sfs.Wms.Inventory.Application.Contracts;
using Win_in.Sfs.Wms.Store.Application.Contracts;

namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent;

[DependsOn(
    typeof(AbpAutofacModule),
    typeof(AbpAutoMapperModule),
    typeof(AbpBackgroundJobsModule),
    typeof(AbpBackgroundWorkersModule),
    typeof(AbpHttpClientModule)
)]
[DependsOn(
    typeof(AuthApplicationContractsModule),
    typeof(StoreApplicationContractsModule),
    typeof(InventoryApplicationContractsModule),
    typeof(LabelApplicationContractsModule),
    typeof(DataExchangeDomainModule),
    typeof(DataExchangeEntityFrameworkCoreModule),
    typeof(DataExchangeDomainFawtygTyrpModule),
    typeof(DataExchangeDapperFawtygModule),
    typeof(DataExchangeEntityFrameworkCoreFawtygModule),
    typeof(AbpAccountApplicationContractsModule)
    )]
public class TyrpAgentModule : AbpModule
{

    public override void PreConfigureServices(ServiceConfigurationContext context)
    {

        PreConfigure<AbpHttpClientBuilderOptions>(options =>
        {
            //Polly 重试3次
            options.ProxyClientBuildActions.Add((remoteServiceName, clientBuilder) =>
            {
                clientBuilder.AddTransientHttpErrorPolicy(policyBuilder =>
                    policyBuilder.WaitAndRetryAsync(
                        3,
                        i => TimeSpan.FromSeconds(Math.Pow(2, i))
                    )
                );
            });

            //默认添加Authorization Header: Bearer Token
            options.ProxyClientActions.Add((a, s, h) =>
            {
                var httpAuthorizationHandler = s.GetService<HttpAuthorizationHandler>();
                if (httpAuthorizationHandler != null && httpAuthorizationHandler.IsLoggedIn())
                {
                    h.DefaultRequestHeaders.Authorization =
                        new AuthenticationHeaderValue("Bearer", httpAuthorizationHandler.GetCurrentBearer());
                }
            });
        });

    }

    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        var configuration = context.Services.GetConfiguration();
        var env = context.Services.GetSingletonInstance<IHostEnvironment>();

        context.SetConsoleTitleOfConsoleApp("TyrpAgent", env.EnvironmentName);

        ConfigureDbContext();

        ConfigureOptions(configuration);

        context.Services.AddHostedService<TyrpAgentHostedService>();

        ConfigureAutoMapper(context);

        ConfigureHttpClientProxies(context);

        ConfigureAuthentication(context, configuration);
    }

    private void ConfigureDbContext()
    {
        Configure<AbpDbContextOptions>(options =>
        {
            options.UseSqlServer();
        });
    }

    private void ConfigureOptions(IConfiguration configuration)
    {
        Configure<TyrpOptions>(configuration.GetSection("TyrpOptions"));
    }

    private void ConfigureAutoMapper(ServiceConfigurationContext context)
    {
        context.Services.AddAutoMapperObjectMapper<TyrpAgentModule>();
        Configure<AbpAutoMapperOptions>(options => { options.AddMaps<TyrpAgentModule>(validate: false); });
    }

    private static void ConfigureAuthentication(ServiceConfigurationContext context, IConfiguration configuration)
    {
        var isAlwaysAllowAuthorization = configuration.GetValue<bool>("AuthServer:AlwaysAllowAuthorization");
        if (isAlwaysAllowAuthorization)
        {
            //绕过授权服务,用于测试
            context.Services.AddAlwaysAllowAuthorization();
        }
        else
        {

            context.Services.AddAuthentication()
            .AddJwtBearer(options =>
            {
                options.Authority = configuration["AuthServer:Authority"];
                options.RequireHttpsMetadata = Convert.ToBoolean(configuration["AuthServer:RequireHttpsMetadata"]);
                options.Audience = "DataExchange";
                options.BackchannelHttpHandler = new HttpClientHandler
                {
                    ServerCertificateCustomValidationCallback =
                        HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
                };
            });
        }
    }

    private static void ConfigureHttpClientProxies(ServiceConfigurationContext context)
    {
        context.Services.AddHttpClientProxies(
            typeof(BasedataApplicationContractsModule).Assembly,
            "BaseData"
        );
        context.Services.AddHttpClientProxies(
          typeof(AbpAccountApplicationContractsModule).Assembly,
          "Auth"
      );
        context.Services.AddHttpClientProxies(
            typeof(StoreApplicationContractsModule).Assembly,
            "Store"
        );
        context.Services.AddHttpClientProxies(
            typeof(LabelApplicationContractsModule).Assembly,
            "Label"
        );
        context.Services.AddHttpClientProxies(
            typeof(AuthApplicationContractsModule).Assembly,
            "Auth");
    }

    public override void OnApplicationInitialization(
        ApplicationInitializationContext context)
    {

        context.AddBackgroundWorkerAsync<TyrpIncomingBackgroundWorker>();
        context.AddBackgroundWorkerAsync<TyrpOutgoingBackgroundWorker>();
    }

}