hotline/src/Hotline.Application.Tests/Startup.cs

using Microsoft.AspNetCore.Hosting;
using Tr.Sdk;
using Hotline.Repository.SqlSugar.Extensions;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Hotline.Api;
using Microsoft.AspNetCore.Identity;
using XF.Domain.Dependency;
using System.Reflection;
using Hotline.DI;
using XF.Domain.Repository;
using Hotline.Repository.SqlSugar;
using Hotline.Repository.SqlSugar.DataPermissions;
using Hotline.Configurations;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Builder;
using Xunit.DependencyInjection.AspNetCoreTesting;
using Polly;
using Hotline.Share.Tools;
using Hotline.Users;
using Hotline.Identity;
using XF.Domain.Cache;
using XF.EasyCaching;
using Mapster;
using Hotline.EventBus;
using XF.Utility.MQ;
using Microsoft.Extensions.DependencyInjection.Extensions;
using DotNetCore.CAP;
using XF.Domain.Options;
using Hotline.Settings.TimeLimitDomain;
using Hotline.Settings.TimeLimitDomain.ExpireTimeSupplier;
using Microsoft.AspNetCore.WebSockets;
using Hotline.CallCenter.Configs;

namespace Hotline.Application.Tests;
public class Startup
{
    private const string JsonFile = "appsettings.Development.json";
    public void ConfigureHost(IHostBuilder hostBuilder)
    {
        //hostBuilder
        //.ConfigureHostConfiguration(builder =>
        //{
        //    builder.AddJsonFile("appsettings.Development.json", optional: true, reloadOnChange: true)
        //    .AddEnvironmentVariables();
        //});
        hostBuilder
            .ConfigureWebHost(webHostBuilder => webHostBuilder
            .UseTestServerAndAddDefaultHttpClient()
            .ConfigureAppConfiguration((hostingContext, config) =>
            {
                config.AddJsonFile(JsonFile);
            })
            .UseStartup<AspNetCoreStartup>()) ;
    }

    private class AspNetCoreStartup
    {
        public AspNetCoreStartup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services) 
        {
            AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
            var configuration = Configuration;
            var appConfigurationSection = configuration.GetRequiredSection(nameof(AppConfiguration));
            var appConfiguration = appConfigurationSection.Get<AppConfiguration>();
            if (appConfiguration is null) throw new ArgumentNullException(nameof(appConfiguration));

            //var callCenterConfigurationSection = configuration.GetRequiredSection(nameof(CallCenterConfiguration));
            //var callCenterConfiguration = callCenterConfigurationSection.Get<CallCenterConfiguration>();
            //services.AddTrSdk(callCenterConfiguration.TianRun.Address,
            //            callCenterConfiguration.TianRun.Username,
            //            callCenterConfiguration.TianRun.Password);


            services.Configure<AppConfiguration>(d => appConfigurationSection.Bind(d));
            services.Configure<IdentityConfiguration>(d => configuration.GetSection(nameof(IdentityConfiguration)).Bind(d));

            services.RegisterMapper();

            //sqlsugar
            services.AddSqlSugar(configuration);

            // application services
            // services.AddScoped<ISnapshotApplication, SnapshotApplication>();

            //mq
            services.AddTestMq(configuration);

            services.AddScoped<IDataPermissionFilterBuilder, DataPermissionFilterBuilder>();
            services.AddScoped(typeof(IRepository<>), typeof(BaseRepository<>));
            services.AddScoped<IHttpContextAccessor, DefaultHttpContextAccessor>();
            services.AddCache(d =>
            {
                var cacheConfig = configuration.GetSection("Cache").Get<CacheOptions>();
                cacheConfig.Adapt(d);
                d.Prefix = "Hotline";
                d.TopicName = "hotline-topic";
            });
            services.AddScoped(typeof(IPasswordHasher<>), typeof(PasswordHasher<>));
            services.AddScoped(typeof(ITypedCache<>), typeof(DefaultTypedCache<>));
            services.RegisterMediatR(appConfiguration);

            // services.AddSenparcWeixinServices(configuration);
            AppDomain.CurrentDomain.GetAssemblies().ToList().SelectMany(d => d.GetTypes())
                .Where(d => d.GetInterfaces().Any(x =>
                    x == typeof(IScopeDependency)
                    || x == typeof(ISingletonDependency)
                    || x == typeof(ITransientDependency))
                            && d.GetInterfaces().All(x => x != typeof(IIgnoreDependency)))
                .ToList()
                .ForEach(d => ServiceRegister.Register(services, d));

            //services.AddScoped<IThirdIdentiyService, ThirdTestService>();
            // services.AddScoped<IThirdIdentiyService, WeChatService>();

            //services.AddScoped<IThirdAccountRepository, ThirdAccountRepository>();
            services.AddApplication();
            services.AddScoped<IExpireTimeSupplier, DaySupplier>();
            services.AddScoped<IExpireTimeSupplier, WorkDaySupplier>();
            services.AddScoped<IExpireTimeSupplier, HourSupplier>();
            services.AddScoped<ExpireTimeFactory>();
            services.AddScoped<YiBinExpireTimeLimit>();
            services.AddScoped<ZiGongExpireTimeLimit>();

            ServiceLocator.Instance = services.BuildServiceProvider();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            // app.UseSenparcWeixin(env, null, null, register => { }, (register, weixinSetting) => { });
        }
    }
}

public static class StartupHelper
{
    public static IServiceCollection RegisterMediatR(this IServiceCollection services, AppConfiguration appConfiguration)
    {
        services.AddScoped<Publisher>();
        services.AddMediatR(cfg =>
        {
            cfg.TypeEvaluator = d =>
            {
                var attr = d.GetCustomAttribute(typeof(InjectionAttribute)) as InjectionAttribute;
                if (attr is null) return true;
                return attr.IsEnable(appConfiguration.AppScope,
                    appConfiguration.GetDefaultAppScopeConfiguration().CallCenterType);
            };
            cfg.RegisterServicesFromAssembly(typeof(ApplicationStartupExtensions).Assembly);
        });

        return services;
    }

    public static IServiceCollection AddTestMq(this IServiceCollection services, IConfiguration configuration)
    {
        MqConfiguration mqConfiguration = configuration.GetSection("MqConfiguration").Get<MqConfiguration>();
        services.AddCap(delegate (CapOptions x)
        {
            if (!(mqConfiguration.DbType == "PostgreSql"))
            {
                throw new ArgumentOutOfRangeException();
            }

            x.UsePostgreSql(mqConfiguration.DbConnectionString);
            if (!(mqConfiguration.MqType == "RabbitMq"))
            {
                throw new ArgumentOutOfRangeException();
            }

            RabbitMq rabbitmq = mqConfiguration.RabbitMq;
            if (rabbitmq == null)
            {
                throw new ArgumentNullException("未配置RabbitMq参数");
            }

            x.UseRabbitMQ(delegate (RabbitMQOptions d)
            {
                d.UserName = rabbitmq.UserName;
                d.Password = rabbitmq.Password;
                d.HostName = rabbitmq.HostName;
                d.Port = rabbitmq.Port;
                d.VirtualHost = rabbitmq.VirtualHost;
            });

            if (!string.IsNullOrEmpty(mqConfiguration.DefaultGroup))
            {
                x.DefaultGroupName = mqConfiguration.DefaultGroup;
            }

            if (!string.IsNullOrEmpty(mqConfiguration.TopicNamePrefix))
            {
                x.TopicNamePrefix = mqConfiguration.TopicNamePrefix;
            }
        });
        return services;
    }
}