temp

src/Hotline.Api/Controllers/CommonPController.cs

@@ -39,7 +39,7 @@ namespace Hotline.Api.Controllers
         private readonly IOrderScreenRepository _orderScreenRepository;
         private readonly IRepository<OrderVisitDetail> _orderVisitedDetailRepository;
         private readonly ICallApplication _callApplication;
-        private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
+        private readonly IOptionsSnapshot<AppConfiguration> _appOptions;
 
         public CommonPController(
             ISystemCommonOpinionDomainService commonOpinionDomainService,
@@ -53,7 +53,7 @@ namespace Hotline.Api.Controllers
             IOrderScreenRepository orderScreenRepository,
             IRepository<OrderVisitDetail> orderVisitedDetailRepository,
             ICallApplication callApplication,
-            IOptionsSnapshot<CallCenterConfiguration> callcenterOptions)
+            IOptionsSnapshot<AppConfiguration> appOptions)
         {
             _commonOpinionDomainService = commonOpinionDomainService;
             _systemAreaDomainService = systemAreaDomainService;
@@ -66,7 +66,7 @@ namespace Hotline.Api.Controllers
             _orderScreenRepository = orderScreenRepository;
             _orderVisitedDetailRepository = orderVisitedDetailRepository;
             _callApplication = callApplication;
-            _callcenterOptions = callcenterOptions;
+            _appOptions = appOptions;
         }
 
 
@@ -110,7 +110,7 @@ namespace Hotline.Api.Controllers
                 int callNum = 0, validCallNum = 0, answeredNum = 0;
                 var answeredRate = string.Empty;
                 var today = DateTime.Today.Date;
-                if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.TianRun)
+                if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.TianRun)
                 {
                     var calls = await _callApplication.QueryTianrunCallsAsync(
                         direction: ECallDirection.In,
@@ -125,7 +125,7 @@ namespace Hotline.Api.Controllers
                         ? Math.Round((double.Parse(answeredNum.ToString()) / double.Parse(validCallNum.ToString())) * 100, 2) + "%"
                         : "-";
                 }
-                else if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.XingTang)
+                else if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XingTang)
                 {
                     var calls = await _callApplication.QueryCallsAsync(
                         callStartTimeStart: today,

src/Hotline.Api/Controllers/OrderController.cs

@@ -123,7 +123,7 @@ public class OrderController : BaseController
     private readonly IRepository<ExternalCitizens> _externalCitizensRepository;
     private readonly IRepository<OrderModifyingRecords> _orderModifyingRecordsRepository;
     private readonly ICallApplication _callApplication;
-    private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
+    private readonly IOptionsSnapshot<AppConfiguration> _appOptions;
     private readonly IOrderSendBackAuditApplication _orderSendBackAuditApplication;
     private readonly IRepository<ContingencyManagementOrders> _contingencyManagementOrdersRepository;
     private readonly IRepository<ContingencyManagementHotspot> _contingencyManagementHotspotRepository;
@@ -182,7 +182,7 @@ public class OrderController : BaseController
         IRepository<OrderCopy> orderCopyRepository,
         IRepository<ExternalCitizens> externalCitizensRepository,
         ICallApplication callApplication,
-        IOptionsSnapshot<CallCenterConfiguration> callcenterOptions,
+        IOptionsSnapshot<AppConfiguration> appOptions,
         IRepository<OrderModifyingRecords> orderModifyingRecordsRepository,
         IOrderSendBackAuditApplication orderSendBackAuditApplication,
         IRepository<ContingencyManagementOrders> contingencyManagementOrdersRepository,
@@ -243,7 +243,7 @@ public class OrderController : BaseController
         _externalCitizensRepository = externalCitizensRepository;
         _orderModifyingRecordsRepository = orderModifyingRecordsRepository;
         _callApplication = callApplication;
-        _callcenterOptions = callcenterOptions;
+        _appOptions = appOptions;
         _orderSendBackAuditApplication = orderSendBackAuditApplication;
         _contingencyManagementOrdersRepository = contingencyManagementOrdersRepository;
         _contingencyManagementHotspotRepository = contingencyManagementHotspotRepository;
@@ -909,7 +909,7 @@ public class OrderController : BaseController
         var recordingBaseAddress = "";
         var recordingAbsolutePath = "";
         var aiVisitVoiceBaseUrl = "";
-        if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.TianRun)
+        if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.TianRun)
         {
             var callRecord = await _callApplication.GetTianrunCallAsync(orderVisit.CallId, HttpContext.RequestAborted);
             if (callRecord != null)
@@ -919,7 +919,7 @@ public class OrderController : BaseController
                 recordingAbsolutePath = callRecord.RecordingAbsolutePath;
             }
         }
-        else if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.XingTang)
+        else if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XingTang)
         {
             var call = await _callApplication.GetCallAsync(orderVisit.CallId, HttpContext.RequestAborted);
             if (call is not null)
@@ -2855,7 +2855,7 @@ public class OrderController : BaseController
 
         if (!string.IsNullOrEmpty(order.CallId))
         {
-            if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.TianRun)
+            if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.TianRun)
             {
                 var callRecord = await _callApplication.GetTianrunCallAsync(order.CallId, HttpContext.RequestAborted);
                 if (callRecord != null)
@@ -2864,7 +2864,7 @@ public class OrderController : BaseController
                     dto.RecordingAbsolutePath = callRecord.RecordingAbsolutePath;
                 }
             }
-            else if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.XingTang)
+            else if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XingTang)
             {
                 var call = await _callApplication.GetCallAsync(order.CallId, HttpContext.RequestAborted);
                 if (call is not null)
@@ -2955,7 +2955,7 @@ public class OrderController : BaseController
         //    callRecord.CallOrderType = Share.Enums.CallCenter.ECallOrderType.Order;
         //    await _trCallRecordRepository.UpdateAsync(callRecord, HttpContext.RequestAborted);
         //}
-        if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.TianRun)
+        if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.TianRun)
         {
             if (!string.IsNullOrEmpty(order.CallId))
                 await _callApplication.RelateTianrunCallWithOrderAsync(order.CallId, order.Id, HttpContext.RequestAborted);
@@ -5052,14 +5052,14 @@ public class OrderController : BaseController
 
         var oneCallTime = DateTime.Now;
         var lastCallTime = DateTime.Now;
-        if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.TianRun)
+        if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.TianRun)
         {
             var calls = await _callApplication.QueryTianrunCallsAsync(phone, ECallDirection.In, cancellationToken: HttpContext.RequestAborted);
             oneCallTime = calls.FirstOrDefault()?.CreatedTime ?? DateTime.Now;
             var count = calls.Count;
             lastCallTime = count > 1 ? calls[count - 2].CreatedTime : oneCallTime;
         }
-        else if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.XingTang)
+        else if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XingTang)
         {
             var calls = await _callApplication.QueryCallsAsync(phone, ECallDirection.In, cancellationToken: HttpContext.RequestAborted);
             oneCallTime = calls.FirstOrDefault()?.BeginIvrTime ?? DateTime.Now;
@@ -5093,7 +5093,7 @@ public class OrderController : BaseController
         //    callBackNum = callsHistory.Count(x => x.CallDirection == ECallDirection.Out);
         //}
 
-        if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.TianRun)
+        if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.TianRun)
         {
             var callsHistory =
                 await _callApplication.QueryTianrunCallsAsync(phone, cancellationToken: HttpContext.RequestAborted);
@@ -5104,7 +5104,7 @@ public class OrderController : BaseController
                 callBackNum = callsHistory.Count(x => x.CallDirection == ECallDirection.Out);
             }
         }
-        else if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.XingTang)
+        else if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XingTang)
         {
             var histories =
                 await _callApplication.QueryCallsAsync(phone, cancellationToken: HttpContext.RequestAborted);

src/Hotline.Api/Controllers/PbxController.cs

@@ -67,6 +67,7 @@ namespace Hotline.Api.Controllers
 
 
         public PbxController(
+            IServiceProvider serviceProvider,
             ITelRepository telRepository,
             ITelRestRepository telRestRepository,
             ITelDomainService telDomainService,
@@ -75,7 +76,6 @@ namespace Hotline.Api.Controllers
             ITelGroupRepository telGroupRepository,
             IMapper mapper,
             IWorkRepository workRepository,
-            INewRockDeviceManager newRockDeviceManager,
             IUserCacheManager userCacheManager,
             ISessionContext sessionContext,
             ICallRepository callRepository,
@@ -90,6 +90,7 @@ namespace Hotline.Api.Controllers
             IRepository<User> userRepository,
             IWexClient wexClient,
             IWexTelGroupRepository wexTelGroupRepository,
+            IOptionsSnapshot<AppConfiguration> appOptions,
             IOptionsSnapshot<CallCenterConfiguration> options,
             ISystemDicDataCacheManager systemDicDataCacheManager)
         {
@@ -101,7 +102,6 @@ namespace Hotline.Api.Controllers
             _telGroupRepository = telGroupRepository;
             _mapper = mapper;
             _workRepository = workRepository;
-            _newRockDeviceManager = newRockDeviceManager;
             _userCacheManager = userCacheManager;
             _sessionContext = sessionContext;
             _callRepository = callRepository;
@@ -118,6 +118,10 @@ namespace Hotline.Api.Controllers
             _wexTelGroupRepository = wexTelGroupRepository;
             _options = options;
             _systemDicDataCacheManager = systemDicDataCacheManager;
+            if (appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XunShi)
+            {
+                _newRockDeviceManager = serviceProvider.GetRequiredService<INewRockDeviceManager>();
+            }
         }
 
 

src/Hotline.Api/StartupExtensions.cs

@@ -131,10 +131,10 @@ internal static class StartupExtensions
 
         //callcenter
         var callcenterType = appConfiguration.GetDefaultAppScopeConfiguration().CallCenterType;
-        services.AddNewRock(callCenterConfiguration.NewRock);
         switch (callcenterType)
         {
             case AppDefaults.CallCenterType.XunShi:
+                services.AddNewRock(callCenterConfiguration.NewRock);
                 break;
             case AppDefaults.CallCenterType.WeiErXin:
                 services

src/Hotline.Application/Handlers/CallCenter/CallState/DtmfNotificationHandler.cs

@@ -11,14 +11,14 @@ using NewRock.Sdk;
 
 namespace Hotline.Application.Handlers.CallCenter.CallState
 {
-    public class DtmfNotificationHandler : BaseHandler, INotificationHandler<DtmfNotification>
+    public class DtmfNotificationHandler : NewRockBaseHandler, INotificationHandler<DtmfNotification>
     {
         private readonly IIvrDomainService _ivrDomainService;
         private readonly ICallRepository _callRepository;
         private readonly ICallDetailRepository _callDetailRepository;
 
 
-        public DtmfNotificationHandler(IIvrDomainService ivrDomainService, ICallDetailRepository callDetailRepository, ICallRepository callRepository, INewRockClient newRockClient, IOptionsSnapshot<CallCenterConfiguration> options,ICallCacheManager callCacheManager,IRealtimeService realtimeService) :base(newRockClient, options,callRepository, callCacheManager,realtimeService)
+        public DtmfNotificationHandler(IIvrDomainService ivrDomainService, ICallDetailRepository callDetailRepository, ICallRepository callRepository, INewRockClient newRockClient, IOptionsSnapshot<CallCenterConfiguration> callcenterOptions,ICallCacheManager callCacheManager,IRealtimeService realtimeService) :base(newRockClient, callcenterOptions,callRepository, callCacheManager,realtimeService)
         {
             _ivrDomainService = ivrDomainService;
             _callDetailRepository = callDetailRepository;

src/Hotline.Application/Handlers/CallCenter/ExtState/IdleNotificationHandler.cs

@@ -9,6 +9,7 @@ using Hotline.Repository.SqlSugar.CallCenter;
 using Hotline.Share.Enums.CallCenter;
 using Hotline.Share.Notifications.NewRockCallCenter;
 using MediatR;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using XF.Domain.Cache;
 using XF.Domain.Exceptions;
@@ -24,22 +25,30 @@ namespace Hotline.Application.Handlers.CallCenter.ExtState
         private readonly IRealtimeService _realtimeService;
         private readonly INewRockDeviceManager _newRockDeviceManager;
         private readonly ITelRestRepository _telRestRepository;
-        private readonly IOptionsSnapshot<CallCenterConfiguration> _options;
+        private readonly IOptionsSnapshot<AppConfiguration> _appOptions;
+        private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
 
-        public IdleNotificationHandler(ITelRepository telRepository, ITelCacheManager telCacheManager, 
+        public IdleNotificationHandler(
+            IServiceProvider serviceProvider,
+            ITelRepository telRepository, ITelCacheManager telCacheManager, 
             ITypedCache<Tel> typedCache,IUserCacheManager userCacheManager,
-            IRealtimeService realtimeService,INewRockDeviceManager newRockDeviceManager,
+            IRealtimeService realtimeService,
             ITelRestRepository telRestRepository,
-            IOptionsSnapshot<CallCenterConfiguration> options)
+            IOptionsSnapshot<AppConfiguration> appOptions,
+            IOptionsSnapshot<CallCenterConfiguration> callcenterOptions)
         {
             _telRepository = telRepository;
             _telCacheManager = telCacheManager;
             _typedCache = typedCache;
             _userCacheManager = userCacheManager;
             _realtimeService = realtimeService;
-            _newRockDeviceManager = newRockDeviceManager;
             _telRestRepository = telRestRepository;
-            _options = options;
+            _appOptions = appOptions;
+            _callcenterOptions = callcenterOptions;
+            if (appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XunShi)
+            {
+                _newRockDeviceManager = serviceProvider.GetRequiredService<INewRockDeviceManager>();
+            }
         }
 
         public async Task Handle(IdleNotification notification, CancellationToken cancellationToken)
@@ -69,7 +78,7 @@ namespace Hotline.Application.Handlers.CallCenter.ExtState
             {
                 foreach (var group in telModel.Groups)
                 {
-                    await _newRockDeviceManager.AssginConfigGroupAsync(_options.Value.NewRock, group.No, group.Distribution, new List<string>() { notification.TelNo }, group.Voice, cancellationToken);
+                    await _newRockDeviceManager.AssginConfigGroupAsync(_callcenterOptions.Value.NewRock, group.No, group.Distribution, new List<string>() { notification.TelNo }, group.Voice, cancellationToken);
                 }
             }
         }

src/Hotline.Application/Handlers/CallCenter/FlowControl/EndOfAnnOuterToMenuNotificationHandler.cs

@@ -11,12 +11,12 @@ using NewRock.Sdk;
 
 namespace Hotline.Application.Handlers.CallCenter.FlowControl
 {
-    public class EndOfAnnOuterToMenuNotificationHandler:BaseHandler,INotificationHandler<EndOfAnnOuterToMenuNotification>
+    public class EndOfAnnOuterToMenuNotificationHandler:NewRockBaseHandler,INotificationHandler<EndOfAnnOuterToMenuNotification>
     {
         private readonly ICallRepository _callRepository;
         private readonly ICallDetailRepository _callDetailRepository;
         private readonly IIvrDomainService _ivrDomainService;
-        public EndOfAnnOuterToMenuNotificationHandler(ICallRepository callRepository, ICallDetailRepository callDetailRepository, IIvrDomainService ivrDomainService, INewRockClient newRockClient, IOptionsSnapshot<CallCenterConfiguration> options,ICallCacheManager callCacheManager,IRealtimeService realtimeService) : base(newRockClient, options,callRepository,callCacheManager, realtimeService)
+        public EndOfAnnOuterToMenuNotificationHandler(ICallRepository callRepository, ICallDetailRepository callDetailRepository, IIvrDomainService ivrDomainService, INewRockClient newRockClient, IOptionsSnapshot<CallCenterConfiguration> callcenterOptions,ICallCacheManager callCacheManager,IRealtimeService realtimeService) : base(newRockClient, callcenterOptions,callRepository,callCacheManager, realtimeService)
         {
             _callRepository = callRepository;
             _callDetailRepository = callDetailRepository;

src/Hotline.Application/Handlers/CallCenter/FlowControl/EndOfAnnVisitorToMenuNotificationHandler.cs

@@ -12,13 +12,13 @@ using NewRock.Sdk;
 namespace Hotline.Application.Handlers.CallCenter.FlowControl
 {
 
-    public class EndOfAnnVisitorToMenuNotificationHandler:BaseHandler,INotificationHandler<EndOfAnnVisitorToMenuNotification>
+    public class EndOfAnnVisitorToMenuNotificationHandler:NewRockBaseHandler,INotificationHandler<EndOfAnnVisitorToMenuNotification>
     {
         private readonly ICallRepository _callRepository;
         private readonly ICallDetailRepository _callDetailRepository;
         private readonly IIvrDomainService _ivrDomainService;
 
-        public EndOfAnnVisitorToMenuNotificationHandler(ICallRepository callRepository, ICallDetailRepository callDetailRepository, IIvrDomainService ivrDomainService,INewRockClient newRockClient, IOptionsSnapshot<CallCenterConfiguration> options,ICallCacheManager callCacheManager,IRealtimeService realtimeService):base(newRockClient,options,callRepository,callCacheManager, realtimeService)
+        public EndOfAnnVisitorToMenuNotificationHandler(ICallRepository callRepository, ICallDetailRepository callDetailRepository, IIvrDomainService ivrDomainService,INewRockClient newRockClient, IOptionsSnapshot<CallCenterConfiguration> callcenterOptions,ICallCacheManager callCacheManager,IRealtimeService realtimeService):base(newRockClient,callcenterOptions,callRepository,callCacheManager, realtimeService)
         {
             _callRepository = callRepository;
             _callDetailRepository = callDetailRepository;

src/Hotline.Application/Handlers/CallCenter/BaseHandler.cs → src/Hotline.Application/Handlers/CallCenter/NewRockBaseHandler.cs

@@ -1,6 +1,7 @@
 using Hotline.Caching.Interfaces;
 using Hotline.CallCenter.Calls;
 using Hotline.CallCenter.Configs;
+using Hotline.EventBus;
 using Hotline.Realtimes;
 using Hotline.Share.Dtos.CallCenter;
 using Hotline.Share.Enums.CallCenter;
@@ -12,14 +13,20 @@ using NewRock.Sdk.Transfer.Queue.Request;
 
 namespace Hotline.Application.Handlers.CallCenter
 {
-    public class BaseHandler
+    [HandlerInject(Labels =)]
+    public class NewRockBaseHandler
     {
         private readonly INewRockClient _newRockClient;
         private readonly IOptionsSnapshot<CallCenterConfiguration> _options;
         private readonly ICallRepository _callRepository;
         private readonly ICallCacheManager _callCacheManager;
         private readonly IRealtimeService _realtimeService;
-        public BaseHandler(INewRockClient newRockClient, IOptionsSnapshot<CallCenterConfiguration> options,ICallRepository callRepository,ICallCacheManager callCacheManager,IRealtimeService realtimeService)
+        public NewRockBaseHandler(
+            INewRockClient newRockClient, 
+            IOptionsSnapshot<CallCenterConfiguration> options,
+            ICallRepository callRepository,
+            ICallCacheManager callCacheManager,
+            IRealtimeService realtimeService)
         {
             _newRockClient = newRockClient;
             _options = options;

src/Hotline.Application/Handlers/CallCenter/System/BootupNotificationHandler.cs

@@ -6,6 +6,7 @@ using Hotline.CallCenter.Tels;
 using Hotline.NewRock;
 using Hotline.Share.Notifications.NewRockCallCenter;
 using MediatR;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 
 namespace Hotline.Application.Handlers.CallCenter.System
@@ -14,19 +15,25 @@ namespace Hotline.Application.Handlers.CallCenter.System
     {
         private readonly ITelGroupRepository _telGroupRepository;
         private readonly IIvrRepository _ivrRepository;
-        private readonly IOptionsSnapshot<CallCenterConfiguration> _options;
+        private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
         private readonly INewRockDeviceManager _newRockDeviceManager;
         private readonly IUserCacheManager _userCacheManager;
 
-        public BootupNotificationHandler(ITelGroupRepository telGroupRepository, INewRockDeviceManager newRockDeviceManager,
+        public BootupNotificationHandler(
+            IServiceProvider serviceProvider,
+            ITelGroupRepository telGroupRepository,
             IUserCacheManager userCacheManager, IIvrRepository ivrRepository,
-            IOptionsSnapshot<CallCenterConfiguration> options)
+            IOptionsSnapshot<AppConfiguration> appOptions,
+            IOptionsSnapshot<CallCenterConfiguration> callcenterOptions)
         {
             _telGroupRepository = telGroupRepository;
-            _newRockDeviceManager = newRockDeviceManager;
             _userCacheManager = userCacheManager;
             _ivrRepository = ivrRepository;
-            _options = options;
+            _callcenterOptions = callcenterOptions;
+            if (appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XunShi)
+            {
+                _newRockDeviceManager = serviceProvider.GetRequiredService<INewRockDeviceManager>();
+            }
         }
 
         public async Task Handle(BootupNotification notification, CancellationToken cancellationToken)
@@ -45,7 +52,7 @@ namespace Hotline.Application.Handlers.CallCenter.System
 
                 }
                 //轮循还原设备分机组信息
-                await _newRockDeviceManager.AssginConfigGroupAsync(_options.Value.NewRock, groupItem.No, groupItem.Distribution, exts, groupItem.Voice,
+                await _newRockDeviceManager.AssginConfigGroupAsync(_callcenterOptions.Value.NewRock, groupItem.No, groupItem.Distribution, exts, groupItem.Voice,
                     cancellationToken);
             }
 
@@ -56,7 +63,7 @@ namespace Hotline.Application.Handlers.CallCenter.System
             var ivrlist = await _ivrRepository.QueryAsync();
             foreach (var item in ivrlist)
             {
-                await _newRockDeviceManager.AssginConfigMenuAsync(_options.Value.NewRock, item.No, item.Voice, item.Repeat.ToString(), item.InfoLength.ToString(), item.Exit, cancellationToken);
+                await _newRockDeviceManager.AssginConfigMenuAsync(_callcenterOptions.Value.NewRock, item.No, item.Voice, item.Repeat.ToString(), item.InfoLength.ToString(), item.Exit, cancellationToken);
             }
             #endregion
 

src/Hotline.Application/Handlers/FlowEngine/WorkflowStartHandler.cs

@@ -1,26 +1,21 @@
 using DotNetCore.CAP;
 using Hotline.Application.CallCenter;
 using Hotline.Application.Quality;
-using Hotline.CallCenter.Calls;
 using Hotline.CallCenter.Configs;
-using Hotline.CallCenter.Tels;
 using Hotline.FlowEngine.Notifications;
 using Hotline.FlowEngine.WorkflowModules;
-using Hotline.FlowEngine.Workflows;
 using Hotline.KnowledgeBase;
 using Hotline.Orders;
 using Hotline.Push.Notifies;
 using Hotline.Share.Dtos.FlowEngine.Workflow;
 using Hotline.Share.Dtos.Order;
 using Hotline.Share.Dtos.TrCallCenter;
-using Hotline.Share.Enums.KnowledgeBase;
 using Hotline.Share.Enums.Push;
 using Hotline.Share.Enums.Quality;
 using Hotline.Share.Mq;
 using Hotline.Users;
 using MapsterMapper;
 using MediatR;
-using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using XF.Domain.Entities;
@@ -38,15 +33,13 @@ namespace Hotline.Application.Handlers.FlowEngine
         private readonly ILogger<WorkflowStartHandler> _logger;
         private readonly IQualityApplication _qualityApplication;
         // private readonly IRepository<TrCallRecord> _trCallRecordRepository;
-        private readonly IOrderScreenRepository _orderScreenRepository;
         private readonly IOrderDelayRepository _orderDelayRepository;
         private readonly IRepository<User> _userRepository;
         private readonly ICallApplication _callApplication;
-        private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
+        private readonly IOptionsSnapshot<AppConfiguration> _appOptions;
         private readonly IMediator _mediator;
-        private readonly IKnowledgeRepository _knowledgeRepository;
 
-		public WorkflowStartHandler(
+        public WorkflowStartHandler(
             IOrderDomainService orderDomainService,
             IKnowledgeDomainService knowledgeDomainService,
             IOrderRepository orderRepository,
@@ -54,14 +47,11 @@ namespace Hotline.Application.Handlers.FlowEngine
             IQualityApplication qualityApplication,
             IMapper mapper,
             ILogger<WorkflowStartHandler> logger,
-            // IRepository<TrCallRecord> trCallRecordRepository,
-            IOrderScreenRepository orderScreenRepository,
             IOrderDelayRepository orderDelayRepository,
             IRepository<User> userRepository,
             ICallApplication callApplication,
-            IOptionsSnapshot<CallCenterConfiguration> callcenterOptions,
-            IMediator mediator,
-            IKnowledgeRepository knowledgeRepository
+            IOptionsSnapshot<AppConfiguration> appOptions,
+            IMediator mediator
 		)
         {
             _orderDomainService = orderDomainService;
@@ -72,14 +62,12 @@ namespace Hotline.Application.Handlers.FlowEngine
             _mapper = mapper;
             _logger = logger;
             // _trCallRecordRepository = trCallRecordRepository;
-            _orderScreenRepository = orderScreenRepository;
             _orderDelayRepository = orderDelayRepository;
             _userRepository = userRepository;
             _callApplication = callApplication;
-            _callcenterOptions = callcenterOptions;
+            _appOptions = appOptions;
             _mediator = mediator;
-            _knowledgeRepository = knowledgeRepository;
-		}
+        }
 
         /// <summary>Handles a notification</summary>
         /// <param name="notification">The notification</param>
@@ -118,7 +106,7 @@ namespace Hotline.Application.Handlers.FlowEngine
                         if (order.SourceChannelCode == AppDefaults.SourceChannel.DianHua &&
                             !string.IsNullOrEmpty(order.CallId))
                         {
-                            if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.TianRun)
+                            if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.TianRun)
                             {
                                 // var callRecord = await _trCallRecordRepository.GetAsync(p => p.OtherAccept == order.CallId, cancellationToken);
                                 var callRecord = await _callApplication.GetTianrunCallAsync(order?.CallId, cancellationToken);
@@ -127,7 +115,7 @@ namespace Hotline.Application.Handlers.FlowEngine
                                     publishCallRecordDto.TrCallRecordDto = _mapper.Map<TrCallDto>(callRecord);
                                 }
                             }
-                            else if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.XingTang)
+                            else if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XingTang)
                             {
                                 var call = await _callApplication.GetCallAsync(order?.CallId, cancellationToken);
                                 if (call is not null)

src/Hotline.Application/Quality/QualityApplication.cs

@@ -41,7 +41,7 @@ namespace Hotline.Application.Quality
         private readonly ISystemSettingCacheManager _systemSettingCacheManager;
         private readonly ILogger<Hotline.Quality.Quality> _logger;
         private readonly ICallApplication _callApplication;
-        private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
+        private readonly IOptionsSnapshot<AppConfiguration> _appOptions;
         private readonly Publisher _publisher;
         private readonly IRepository<TrCallRecord> _trCallRecordRepository;
 
@@ -56,7 +56,7 @@ namespace Hotline.Application.Quality
             IOrderRepository orderRepository,
             ISystemSettingCacheManager systemSettingCacheManager,
             ICallApplication callApplication,
-            IOptionsSnapshot<CallCenterConfiguration> callcenterOptions,
+            IOptionsSnapshot<AppConfiguration> appOptions,
             ILogger<Hotline.Quality.Quality> logger,
             Publisher publisher,
             IRepository<TrCallRecord> trCallRecordRepository)
@@ -71,7 +71,7 @@ namespace Hotline.Application.Quality
             _orderRepository = orderRepository;
             _systemSettingCacheManager = systemSettingCacheManager;
             _callApplication = callApplication;
-            _callcenterOptions = callcenterOptions;
+            _appOptions = appOptions;
             _logger = logger;
             _publisher = publisher;
             _trCallRecordRepository = trCallRecordRepository;
@@ -167,14 +167,14 @@ namespace Hotline.Application.Quality
                     var audioFile = string.Empty;
                     var fromNo = string.Empty;
                     DateTime? callStartTime = null;
-                    if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.TianRun)
+                    if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.TianRun)
                     {
                         var call = await _callApplication.GetTianrunCallAsync(order.CallId, cancellationToken);
                         audioFile = call.RecordingAbsolutePath;
                         fromNo = call.CPN;
                         callStartTime = call.CreatedTime;
                     }
-                    else if (_callcenterOptions.Value.CallCenterType == AppDefaults.CallCenterType.XingTang)
+                    else if (_appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XingTang)
                     {
                         var call = await _callApplication.GetCallAsync(order.CallId, cancellationToken);
                         audioFile = call.AudioFile;

src/Hotline/CallCenter/Calls/CallDomainService.cs

@@ -1,8 +1,10 @@
 using Hotline.CallCenter.Configs;
 using Hotline.CallCenter.Devices;
 using Hotline.Share.Requests;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using XF.Domain.Dependency;
+using static Hotline.AppDefaults;
 
 namespace Hotline.CallCenter.Calls
 {
@@ -11,18 +13,22 @@ namespace Hotline.CallCenter.Calls
         private readonly INewRockDeviceManager _newRockDeviceManager;
         private readonly ICallRepository _callRepository;
         private readonly ICallDetailRepository _callDetailRepository;
-        private readonly IOptionsSnapshot<CallCenterConfiguration> _options;
+        private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
 
         public CallDomainService(
-            INewRockDeviceManager newRockDeviceManager, 
+            IServiceProvider serviceProvider,
             ICallRepository callRepository, 
             ICallDetailRepository callDetailRepository,
-            IOptionsSnapshot<CallCenterConfiguration> options)
+            IOptionsSnapshot<AppConfiguration> appOptions,
+            IOptionsSnapshot<CallCenterConfiguration> callcenterOptions)
         {
-            _newRockDeviceManager = newRockDeviceManager;
             _callRepository = callRepository;
             _callDetailRepository = callDetailRepository;
-            _options = options;
+            _callcenterOptions = callcenterOptions;
+            if (appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XunShi)
+            {
+                _newRockDeviceManager = serviceProvider.GetRequiredService<INewRockDeviceManager>();
+            }
         }
 
         #region 来电
@@ -68,7 +74,7 @@ namespace Hotline.CallCenter.Calls
         public async Task VisitorToOuterAsync(VisitorToOuterRequest request, CancellationToken cancellationToken)
         {
             //调用设备接口转外线
-            await _newRockDeviceManager.VisitorToOuterAsync(_options.Value.NewRock, request.VisitorId, request.OuterPhoneNum, cancellationToken);
+            await _newRockDeviceManager.VisitorToOuterAsync(_callcenterOptions.Value.NewRock, request.VisitorId, request.OuterPhoneNum, cancellationToken);
             //写入数据库通话记录
         }
 
@@ -81,7 +87,7 @@ namespace Hotline.CallCenter.Calls
         public async Task VisitorToIvrAsync(VisitorToIvrRequest request, CancellationToken cancellationToken)
         {
             //调用设备接口转语音菜单
-            await _newRockDeviceManager.VisitorToMenuAsync(_options.Value.NewRock, request.VisitorId, request.MenuId, cancellationToken);
+            await _newRockDeviceManager.VisitorToMenuAsync(_callcenterOptions.Value.NewRock, request.VisitorId, request.MenuId, cancellationToken);
             //写入数据库通话记录
         }
 
@@ -93,7 +99,7 @@ namespace Hotline.CallCenter.Calls
         /// <returns></returns>
         public async Task VisitorToTelGroupAsync(VisitorToTelGroupRequest request, CancellationToken cancellationToken)
         {
-            await _newRockDeviceManager.VisitorToGroupAsync(_options.Value.NewRock, request.VisitorId, request.GroupId, cancellationToken);
+            await _newRockDeviceManager.VisitorToGroupAsync(_callcenterOptions.Value.NewRock, request.VisitorId, request.GroupId, cancellationToken);
             //写入数据库通话记录
         }
 
@@ -128,7 +134,7 @@ namespace Hotline.CallCenter.Calls
             //};
             //await _callDetailRepository.AddAsync(detail, cancellationToken);
             //调用设备拨打电话
-            await _newRockDeviceManager.ExtToOuterAsync(_options.Value.NewRock, request.ExtId, request.OuterPhoneNum, cancellationToken);
+            await _newRockDeviceManager.ExtToOuterAsync(_callcenterOptions.Value.NewRock, request.ExtId, request.OuterPhoneNum, cancellationToken);
         }
 
         #endregion
@@ -144,7 +150,7 @@ namespace Hotline.CallCenter.Calls
         public async Task AcceptVisitorAsync(AcceptVisitorRequest request, CancellationToken cancellationToken)
         {
             //调用设备受理
-            await _newRockDeviceManager.AcceptVisitorAsync(_options.Value.NewRock, request.VisitorId, cancellationToken);
+            await _newRockDeviceManager.AcceptVisitorAsync(_callcenterOptions.Value.NewRock, request.VisitorId, cancellationToken);
         }
 
         #endregion
@@ -159,7 +165,7 @@ namespace Hotline.CallCenter.Calls
         /// <returns></returns>
         public async Task MonitorExt(MonitorExtRequest request,CancellationToken cancellationToken)
         {
-            await _newRockDeviceManager.MonitorExtAsync(_options.Value.NewRock, request.firstTelNo, request.secondTelNo, cancellationToken);
+            await _newRockDeviceManager.MonitorExtAsync(_callcenterOptions.Value.NewRock, request.firstTelNo, request.secondTelNo, cancellationToken);
         }
 
         /// <summary>
@@ -173,7 +179,7 @@ namespace Hotline.CallCenter.Calls
         /// <returns></returns>
         public async Task MonitorExtToTalk(MonitorExtToTalkRequest request,CancellationToken cancellationToken)
         {
-            await _newRockDeviceManager.MonitorExtToTalkAsync(_options.Value.NewRock, request.telNo, cancellationToken);
+            await _newRockDeviceManager.MonitorExtToTalkAsync(_callcenterOptions.Value.NewRock, request.telNo, cancellationToken);
         }
 
         /// <summary>
@@ -187,7 +193,7 @@ namespace Hotline.CallCenter.Calls
         /// <returns></returns>
         public async Task MonitorExtToListen(MonitorExtToListenRequest request,CancellationToken cancellationToken)
         {
-            await _newRockDeviceManager.MonitorExtToListenAsync(_options.Value.NewRock, request.telNo, cancellationToken);
+            await _newRockDeviceManager.MonitorExtToListenAsync(_callcenterOptions.Value.NewRock, request.telNo, cancellationToken);
         }
 
         #endregion
@@ -205,7 +211,7 @@ namespace Hotline.CallCenter.Calls
         /// <returns></returns>
         public async Task BargeinExt(BargeinExtRequest request,CancellationToken cancellationToken)
         {
-            await _newRockDeviceManager.BargeinExtAsync(_options.Value.NewRock, request.firstTelNo, request.secondTelNo, cancellationToken);
+            await _newRockDeviceManager.BargeinExtAsync(_callcenterOptions.Value.NewRock, request.firstTelNo, request.secondTelNo, cancellationToken);
         }
 
         #endregion

src/Hotline/CallCenter/Ivrs/IvrDomainService.cs

@@ -5,6 +5,7 @@ using Hotline.Settings;
 using Hotline.Share.Dtos.CallCenter;
 using Hotline.Share.Enums.CallCenter;
 using MapsterMapper;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using XF.Domain.Cache;
@@ -25,11 +26,11 @@ public class IvrDomainService : IIvrDomainService, IScopeDependency
     private readonly IMapper _mapper;
     private readonly ILogger<IvrDomainService> _logger;
     private readonly ITypedCache<List<TrunkIvrManager>> _worktimeCache;
-    private readonly IOptionsSnapshot<CallCenterConfiguration> _options;
+    private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
     private readonly IRepository<TrunkIvrManager> _trunkIvrManagerRepository;
 
     public IvrDomainService(
-        INewRockDeviceManager newRockDeviceManager,
+        IServiceProvider serviceProvider,
         IIvrRepository ivrRepository,
         ITypedCache<List<Ivr>> cacheIvrList,
         IIvrCacheManager ivrCacheManager,
@@ -38,10 +39,10 @@ public class IvrDomainService : IIvrDomainService, IScopeDependency
         IMapper mapper,
         ILogger<IvrDomainService> logger,
         ITypedCache<List<TrunkIvrManager>> worktimeCache,
-        IOptionsSnapshot<CallCenterConfiguration> options,
+        IOptionsSnapshot<AppConfiguration> appOptions,
+        IOptionsSnapshot<CallCenterConfiguration> callcenterOptions,
         IRepository<TrunkIvrManager> trunkIvrManagerRepository)
     {
-        _newRockDeviceManager = newRockDeviceManager;
         _ivrRepository = ivrRepository;
         _cacheIvrList = cacheIvrList;
         _ivrCacheManager = ivrCacheManager;
@@ -50,8 +51,12 @@ public class IvrDomainService : IIvrDomainService, IScopeDependency
         _mapper = mapper;
         _logger = logger;
         _worktimeCache = worktimeCache;
-        _options = options;
+        _callcenterOptions = callcenterOptions;
         _trunkIvrManagerRepository = trunkIvrManagerRepository;
+        if (appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XunShi)
+        {
+            _newRockDeviceManager = serviceProvider.GetRequiredService<INewRockDeviceManager>();
+        }
     }
 
     /// <summary>
@@ -169,7 +174,7 @@ public class IvrDomainService : IIvrDomainService, IScopeDependency
         if (existNo)
             throw new UserFriendlyException("IVR编号已存在");
 
-        await _newRockDeviceManager.AssginConfigMenuAsync(_options.Value.NewRock, ivr.No, ivr.Voice, ivr.Repeat.ToString(), ivr.InfoLength.ToString(), ivr.Exit, cancellationToken);
+        await _newRockDeviceManager.AssginConfigMenuAsync(_callcenterOptions.Value.NewRock, ivr.No, ivr.Voice, ivr.Repeat.ToString(), ivr.InfoLength.ToString(), ivr.Exit, cancellationToken);
 
         var exists = await _ivrRepository.AnyAsync(d => d.IvrCategoryId == ivr.IvrCategoryId, cancellationToken);
         ivr.IsRoot = !exists;
@@ -180,7 +185,7 @@ public class IvrDomainService : IIvrDomainService, IScopeDependency
 
     public async Task UpdateIvrAsync(Ivr ivr, CancellationToken cancellationToken = default)
     {
-        await _newRockDeviceManager.AssginConfigMenuAsync(_options.Value.NewRock, ivr.No, ivr.Voice, ivr.Repeat.ToString(), ivr.InfoLength.ToString(), ivr.Exit, cancellationToken);
+        await _newRockDeviceManager.AssginConfigMenuAsync(_callcenterOptions.Value.NewRock, ivr.No, ivr.Voice, ivr.Repeat.ToString(), ivr.InfoLength.ToString(), ivr.Exit, cancellationToken);
 
         await _ivrRepository.UpdateWithoutStrategiesAsync(ivr, cancellationToken);
         _cacheIvrList.Remove(Ivr.Key);

src/Hotline/CallCenter/Tels/TelDomainService.cs

@@ -11,6 +11,7 @@ using Hotline.Caching.Interfaces;
 using Hotline.CallCenter.Configs;
 using Microsoft.Extensions.Options;
 using Hotline.Share.Dtos.CallCenter;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Hotline.CallCenter.Tels;
 
@@ -23,23 +24,31 @@ public class TelDomainService : ITelDomainService, IScopeDependency
     private readonly IRealtimeService _realtimeService;
     private readonly ITelCacheManager _telCacheManager;
     private readonly IOptionsSnapshot<AppConfiguration> _appOptions;
+    private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
+    private readonly string _callcenterType;
 
     public TelDomainService(
-        INewRockDeviceManager newRockDeviceManager,
+        IServiceProvider serviceProvider,
         ITelRepository telRepository,
         ITelRestRepository telRestRepository,
         ITelHoldRepository telHoldRepository,
         IRealtimeService realtimeService,
         ITelCacheManager telCacheManager,
-        IOptionsSnapshot<AppConfiguration> appOptions)
+        IOptionsSnapshot<AppConfiguration> appOptions,
+        IOptionsSnapshot<CallCenterConfiguration> callcenterOptions)
     {
-        _newRockDeviceManager = newRockDeviceManager;
         _telRepository = telRepository;
         _telRestRepository = telRestRepository;
         _telHoldRepository = telHoldRepository;
         _realtimeService = realtimeService;
         _telCacheManager = telCacheManager;
         _appOptions = appOptions;
+        _callcenterOptions = callcenterOptions;
+        _callcenterType = appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType;
+        if (_callcenterType == AppDefaults.CallCenterType.XunShi)
+        {
+            _newRockDeviceManager = serviceProvider.GetRequiredService<INewRockDeviceManager>();
+        }
     }
 
 
@@ -49,7 +58,7 @@ public class TelDomainService : ITelDomainService, IScopeDependency
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
     public Task<List<Tel>> QueryTelsAsync(CancellationToken cancellationToken)
-        => _newRockDeviceManager.QueryTelsAsync(_options.Value.NewRock, cancellationToken);
+        => _newRockDeviceManager.QueryTelsAsync(_callcenterOptions.Value.NewRock, cancellationToken);
 
     /// <summary>
     /// 查询所有分机组
@@ -57,7 +66,7 @@ public class TelDomainService : ITelDomainService, IScopeDependency
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
     public Task<List<TelGroup>> QueryTelGroupsAsync(CancellationToken cancellationToken)
-        => _newRockDeviceManager.QueryTelGroupsAsync(_options.Value.NewRock, cancellationToken);
+        => _newRockDeviceManager.QueryTelGroupsAsync(_callcenterOptions.Value.NewRock, cancellationToken);
 
     /// <summary>
     /// 分机休息审批流程开始
@@ -129,7 +138,7 @@ public class TelDomainService : ITelDomainService, IScopeDependency
 
         //await _newRockDeviceManager.TelRestAsync(telRest.TelNo, cancellationToken);
 
-        if (_options.Value.CallCenterType == AppDefaults.CallCenterType.XunShi)
+        if (_callcenterType == AppDefaults.CallCenterType.XunShi)
         {
             telRest.StartTime = DateTime.Now;
             telRest.ApplyStatus = ETelRestApplyStatus.Resting;
@@ -138,7 +147,7 @@ public class TelDomainService : ITelDomainService, IScopeDependency
             var tel = _telCacheManager.GetTel(telRest.TelNo);
             foreach (var group in tel.Groups)
             {
-                await _newRockDeviceManager.ModifyGroupExtAsync(_options.Value.NewRock, group.No, group.Distribution, group.Voice, tel.No, true, cancellationToken);
+                await _newRockDeviceManager.ModifyGroupExtAsync(_callcenterOptions.Value.NewRock, group.No, group.Distribution, group.Voice, tel.No, true, cancellationToken);
             }
             #endregion
         }
@@ -190,7 +199,7 @@ public class TelDomainService : ITelDomainService, IScopeDependency
             //更新分机组
             foreach (var group in telCache.Groups)
             {
-                await _newRockDeviceManager.ModifyGroupExtAsync(_options.Value.NewRock, group.No, group.Distribution, group.Voice, "", true, cancellationToken);
+                await _newRockDeviceManager.ModifyGroupExtAsync(_callcenterOptions.Value.NewRock, group.No, group.Distribution, group.Voice, "", true, cancellationToken);
             }
 
             #endregion
@@ -212,7 +221,7 @@ public class TelDomainService : ITelDomainService, IScopeDependency
             var tel = await _telRepository.GetAsync(telId, cancellationToken);
             if (tel is null)
                 throw new UserFriendlyException("无效分机编号");
-            await _newRockDeviceManager.HoldAsync(_options.Value.NewRock, tel.No, cancellationToken);
+            await _newRockDeviceManager.HoldAsync(_callcenterOptions.Value.NewRock, tel.No, cancellationToken);
             await _telHoldRepository.AddAsync(new Calls.TelHold() { TelId = telId, TelNo = tel.No, UserId = userId, UserName = userName, CallId = callId }, cancellationToken);
         }
     }
@@ -228,7 +237,7 @@ public class TelDomainService : ITelDomainService, IScopeDependency
         var tel = await _telRepository.GetAsync(telId, cancellationToken);
         if (tel is null)
             throw new UserFriendlyException("无效分机编号");
-        await _newRockDeviceManager.UnHoldAsync(_options.Value.NewRock, tel.No, cancellationToken);
+        await _newRockDeviceManager.UnHoldAsync(_callcenterOptions.Value.NewRock, tel.No, cancellationToken);
         var holdingTel = await _telHoldRepository.GetAsync(d => d.TelId == telId && d.TelNo == tel.No && d.UserId == userId && d.CallId == callId && !d.EndTime.HasValue);
         if (holdingTel is null)
             throw new UserFriendlyException("未找到分机保持信息");
@@ -248,7 +257,7 @@ public class TelDomainService : ITelDomainService, IScopeDependency
         var tel = await _telRepository.GetAsync(telId, cancellationToken);
         if (tel is null)
             throw new UserFriendlyException("无效分机编号");
-        await _newRockDeviceManager.MuteAsync(_options.Value.NewRock, tel.No, cancellationToken);
+        await _newRockDeviceManager.MuteAsync(_callcenterOptions.Value.NewRock, tel.No, cancellationToken);
     }
 
     /// <summary>
@@ -262,6 +271,6 @@ public class TelDomainService : ITelDomainService, IScopeDependency
         var tel = await _telRepository.GetAsync(telId, cancellationToken);
         if (tel is null)
             throw new UserFriendlyException("无效分机编号");
-        await _newRockDeviceManager.MuteAsync(_options.Value.NewRock, tel.No, cancellationToken);
+        await _newRockDeviceManager.MuteAsync(_callcenterOptions.Value.NewRock, tel.No, cancellationToken);
     }
 }

src/Hotline/EventBus/HandlerInjectAttribute.cs

@@ -18,5 +18,10 @@ namespace Hotline.EventBus
         /// 是否启用
         /// </summary>
         public bool Enable { get; set; } = true;
+
+        /// <summary>
+        /// key=value,key=value
+        /// </summary>
+        public string Labels { get; set; }
     }
 }

src/Hotline/FlowEngine/Workflows/WorkflowDomainService.cs

@@ -119,8 +119,7 @@ namespace Hotline.FlowEngine.Workflows
                 workflow.UpdateCurrentStepWhenHandle(startStep,
                     current.OrgAreaCode, current.OrgAreaName, current.OrgLevel);
 
-                var endTrace = await EndAsync(workflow, dto, firstStepDefine,
-                    startStep, current, expiredTime, cancellationToken);
+                var endTrace = await EndAsync(workflow, dto, firstStepDefine, startStep, current, expiredTime, cancellationToken);
                 return;
             }
 

src/Hotline/Users/UserDomainService.cs

@@ -1,20 +1,16 @@
 using Hotline.Caching.Interfaces;
 using Hotline.CallCenter.Devices;
 using Hotline.CallCenter.Tels;
-using Hotline.Share.Dtos.CallCenter;
-using Hotline.Share.Dtos.TrCallCenter;
 using Hotline.Share.Dtos.Users;
 using MapsterMapper;
-using Microsoft.AspNetCore.Http;
-using System.Security.Cryptography;
 using Hotline.CallCenter.Configs;
 using Microsoft.Extensions.Options;
 using XF.Domain.Authentications;
 using XF.Domain.Cache;
-using XF.Domain.Constants;
 using XF.Domain.Dependency;
 using XF.Domain.Exceptions;
 using XF.Domain.Repository;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Hotline.Users
 {
@@ -29,31 +25,37 @@ namespace Hotline.Users
         private readonly IMapper _mapper;
         private readonly ISystemSettingCacheManager _systemSettingCacheManager;
         private readonly ISessionContext _sessionContext;
-        private readonly IOptionsSnapshot<CallCenterConfiguration> _options;
+        private readonly IOptionsSnapshot<AppConfiguration> _appOptions;
+        private readonly IOptionsSnapshot<CallCenterConfiguration> _callcenterOptions;
 
 
         public UserDomainService(
+            IServiceProvider serviceProvider,
             IRepository<User> userRepository,
             IWorkRepository workRepository,
-            INewRockDeviceManager newRockDeviceManager,
             ITypedCache<Work> cacheWork,
             IUserCacheManager userCacheManager,
             IMapper mapper,
             ITelCacheManager telCacheManager,
             ISystemSettingCacheManager systemSettingCacheManager,
             ISessionContext sessionContext,
-            IOptionsSnapshot<CallCenterConfiguration> options)
+            IOptionsSnapshot<AppConfiguration> appOptions,
+            IOptionsSnapshot<CallCenterConfiguration> callcenterOptions)
         {
             _userRepository = userRepository;
             _workRepository = workRepository;
-            _newRockDeviceManager = newRockDeviceManager;
             _userCacheManager = userCacheManager;
             _cacheWork = cacheWork;
             _mapper = mapper;
             _telCacheManager = telCacheManager;
             _systemSettingCacheManager = systemSettingCacheManager;
             _sessionContext = sessionContext;
-            _options = options;
+            _appOptions = appOptions;
+            _callcenterOptions = callcenterOptions;
+            if (appOptions.Value.GetDefaultAppScopeConfiguration().CallCenterType == AppDefaults.CallCenterType.XunShi)
+            {
+                _newRockDeviceManager = serviceProvider.GetRequiredService<INewRockDeviceManager>();
+            }
         }
 
         /// <summary>
@@ -81,12 +83,12 @@ namespace Hotline.Users
             await _workRepository.AddAsync(work, cancellationToken);
 
             if (!string.IsNullOrEmpty(user.StaffNo))
-                await _newRockDeviceManager.UpdateStaffNoAsync(_options.Value.NewRock, tel.No, user.StaffNo, tel.LineId, cancellationToken);
+                await _newRockDeviceManager.UpdateStaffNoAsync(_callcenterOptions.Value.NewRock, tel.No, user.StaffNo, tel.LineId, cancellationToken);
 
             //更新分机组
             foreach (var group in tel.Groups)
             {
-                await _newRockDeviceManager.AssginConfigGroupAsync(_options.Value.NewRock, group.No, group.Distribution, new List<string>() { tel.No }, group.Voice, cancellationToken);
+                await _newRockDeviceManager.AssginConfigGroupAsync(_callcenterOptions.Value.NewRock, group.No, group.Distribution, new List<string>() { tel.No }, group.Voice, cancellationToken);
             }
 
 
@@ -104,17 +106,17 @@ namespace Hotline.Users
             var tel = _telCacheManager.GetTel(work.TelNo);
             work.OffDuty();
             await _workRepository.UpdateAsync(work, cancellationToken);
-            await _newRockDeviceManager.UpdateStaffNoAsync(_options.Value.NewRock, work.TelNo, string.Empty, tel.LineId, cancellationToken);
+            await _newRockDeviceManager.UpdateStaffNoAsync(_callcenterOptions.Value.NewRock, work.TelNo, string.Empty, tel.LineId, cancellationToken);
             _cacheWork.Remove(work.GetKey(KeyMode.UserId));
             _cacheWork.Remove(work.GetKey(KeyMode.TelNo));
             #region 初始化话机
 
             //初始化解除静音
-            await _newRockDeviceManager.UnMuteAsync(_options.Value.NewRock, tel.No, cancellationToken);
+            await _newRockDeviceManager.UnMuteAsync(_callcenterOptions.Value.NewRock, tel.No, cancellationToken);
 
             foreach (var group in tel.Groups)
             {
-                await _newRockDeviceManager.ModifyGroupExtAsync(_options.Value.NewRock, group.No, group.Distribution, group.Voice, "", false, cancellationToken);
+                await _newRockDeviceManager.ModifyGroupExtAsync(_callcenterOptions.Value.NewRock, group.No, group.Distribution, group.Voice, "", false, cancellationToken);
             }
 
             #endregion