WZC2/be/Modules/Store/src/Win_in.Sfs.Wms.Store.Agent/AgentModule.cs

using System;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Volo.Abp;
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.Basedata.Application.Contracts;
using Win_in.Sfs.Shared.Host;
using Win_in.Sfs.Wms.Inventory.Application.Contracts;
using Win_in.Sfs.Wms.Store.Application.Contracts;
using Win_in.Sfs.Wms.Store.Domain;
using Win_in.Sfs.Wms.Store.EntityFrameworkCore;

namespace Win_in.Sfs.Wms.Store.Agent;

[DependsOn(
    typeof(AbpAutofacModule),
    typeof(AbpAutoMapperModule),
    typeof(AbpBackgroundJobsModule),
    typeof(AbpBackgroundWorkersModule),
    typeof(AbpHttpClientModule)
)]
[DependsOn(
    typeof(StoreDomainModule),
    typeof(StoreEntityFrameworkCoreModule)
    )]
[DependsOn(
    typeof(BasedataApplicationContractsModule),
    typeof(StoreApplicationContractsModule),
    typeof(InventoryApplicationContractsModule)
    )]
public class AgentModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        var configuration = context.Services.GetConfiguration();
        var env = context.Services.GetSingletonInstance<IHostEnvironment>();

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

        Configure<AbpDbContextOptions>(options =>
        {
            options.UseMySQL();
        });

        Configure<StoreOptions>(configuration.GetSection("StoreOptions"));

        context.Services.AddHostedService<AgentHostedService>();

        context.Services.AddAutoMapperObjectMapper<AgentModule>();
        Configure<AbpAutoMapperOptions>(options =>
        {
            options.AddMaps<AgentModule>(validate: false);
        });

        ConfigureHttpClientProxies(context);

        ConfigureAuthentication(context, configuration);
    }

    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(StoreApplicationContractsModule).Assembly,
            "Store"
        );
        context.Services.AddHttpClientProxies(
         typeof(InventoryApplicationContractsModule).Assembly,
         "Inventory"
     );
    }

    public override async Task OnApplicationInitializationAsync(
        ApplicationInitializationContext context)
    {

        await context.AddBackgroundWorkerAsync<AutoCreateMaterialRequestWorker>().ConfigureAwait(false);
    }

}