JiShe.CollectBus/services/JiShe.CollectBus.Application/CollectBusApplicationModule.cs

using JiShe.CollectBus.Common.Consts;
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.FreeSql;
using JiShe.CollectBus.Kafka;
using JiShe.CollectBus.Kafka.AdminClient;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.ScheduledMeterReading;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Cassandra.Mapping;
using JiShe.CollectBus.Cassandra;
using JiShe.CollectBus.FreeRedis;
using JiShe.CollectBus.IoTDB;
using JiShe.CollectBus.Mappers;
using Volo.Abp;
using Volo.Abp.Application;
using Volo.Abp.Autofac;
using Volo.Abp.AutoMapper;
using Volo.Abp.BackgroundWorkers;
using Volo.Abp.BackgroundWorkers.Hangfire;
using Volo.Abp.EventBus;
using Volo.Abp.Modularity;
using Microsoft.Extensions.Options;
using JiShe.CollectBus.Kafka.Internal;
using JiShe.CollectBus.Interceptors;
using JiShe.CollectBus.Common.Attributes;

namespace JiShe.CollectBus;

[DependsOn(
    typeof(CollectBusDomainModule),
    typeof(CollectBusApplicationContractsModule),
    typeof(AbpDddApplicationModule),
    typeof(AbpAutoMapperModule),
    typeof(AbpAutofacModule),
    typeof(AbpBackgroundWorkersHangfireModule),
    typeof(CollectBusFreeRedisModule),
    typeof(CollectBusFreeSqlModule),
    typeof(CollectBusKafkaModule),
    typeof(CollectBusIoTDbModule),
    typeof(CollectBusCassandraModule)
    )]
public class CollectBusApplicationModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        var configuration = context.Services.GetConfiguration();

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

        context.Services.AddSingleton(new MappingConfiguration()
            .Define(new CollectBusMapping()));

        // 注册拦截器
        context.Services.OnRegistered(ctx =>
        {
            var methods = ctx.ImplementationType.GetMethods();
            foreach (var method in methods)
            {
                var attr = method.GetCustomAttribute(typeof(LogInterceptAttribute), true);
                if (attr != null)
                {
                    ctx.Interceptors.TryAdd<LogInterceptor>();
                }
            }
        });
    }

    public override async Task OnApplicationInitializationAsync(
        ApplicationInitializationContext context)
    { 
        var assembly = Assembly.GetExecutingAssembly();
        var types = assembly.GetTypes().Where(t => typeof(ICollectWorker).IsAssignableFrom(t) && !t.IsInterface).ToList();
        foreach (var type in types)
        {
            await context.AddBackgroundWorkerAsync(type);
        }

        //默认初始化表计信息
        var dbContext = context.ServiceProvider.GetRequiredService<EnergySystemScheduledMeterReadingService>();
        await dbContext.InitAmmeterCacheData();
        //await dbContext.InitWatermeterCacheData();

        //初始化主题信息
        var kafkaAdminClient = context.ServiceProvider.GetRequiredService<IAdminClientService>();
        var kafkaOptions = context.ServiceProvider.GetRequiredService<IOptions<KafkaOptionConfig>>();

        var topics = ProtocolConstExtensions.GetAllTopicNamesByIssued();
        topics.AddRange(ProtocolConstExtensions.GetAllTopicNamesByReceived());

        foreach (var item in topics)
        {
            await kafkaAdminClient.CreateTopicAsync(item, kafkaOptions.Value.NumPartitions, kafkaOptions.Value.KafkaReplicationFactor);
        }
    }

}