public QueueService_should()
{
_repositories = CommonHelper.GetService<EndowmentRepositories>();
_handlers = CommonHelper.GetService<EndowmentHandlers>();
_moderatorLevelService = CommonHelper.GetService<IModeratorLevelService>();
_queueService = CommonHelper.GetService<IQueueService>();
}
public QueryTopicConsumeInfoRequestHandler()
{
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_offsetManager = ObjectContainer.Resolve<IOffsetManager>();
_queueService = ObjectContainer.Resolve<IQueueService>();
_consumerManager = ObjectContainer.Resolve<ConsumerManager>();
}
public DirectoryService(IDirectoryRepository directoryRepository, IQueueService queueService, IQueueRepository queueRepository, ILogger logger)
{
_directoryRepository = directoryRepository;
_queueService = queueService;
_queueRepository = queueRepository;
_logger = logger;
}
public ConfigureConnectionViewModel(QueueConnectionContext queueConnectionContext, IQueueService queueService, IDialogService dialogService)
{
_queueConnectionContext = queueConnectionContext;
_queueService = queueService;
_dialogService = dialogService;
ComputerName = _queueConnectionContext.ComputerName;
}
public AdminController(IAdminService adminService,
IUserService userService,
IBanService banService,
IBuildingService buildingService,
IQueueService queueService,
IUserBuildingService userBuildingService,
IUserProductService userProductService,
IMapService mapService,
IMarketService marketService,
IDolarService dolarService,
IDealService dealService,
INotificationService notificationService,
IProductService productService,
IMessageService messageService,
IProductRequirementsService productRService)
{
_adminService = adminService;
_userService = userService;
_banService = banService;
_buildingService = buildingService;
_queueService = queueService;
_userBuildingService = userBuildingService;
_userProductService = userProductService;
_mapService = mapService;
_marketService = marketService;
_dolarService = dolarService;
_dealService = dealService;
_notificationService = notificationService;
_productService = productService;
_messageService = messageService;
_productRService = productRService;
}
public MessageService(IQueueService queueService, IMessageStore messageStore, IOffsetManager offsetManager)
{
_queueService = queueService;
_messageStore = messageStore;
_offsetManager = offsetManager;
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
}
public TwilioHub(IQueueStateHandler queueStateHandler, IQueueService queueService, IQueueProvider queueProvider, IAgentService agentService)
{
_queueStateHandler = queueStateHandler;
_queueService = queueService;
_queueProvider = queueProvider;
_agentService = agentService;
}
public MessageProcessor(IMessageProcessorConfiguration messageProcessorConfiguration, IQueueService queueService,
IMessageSerializationService messageSerializationService)
{
_messageProcessorConfiguration = messageProcessorConfiguration;
_queueService = queueService;
_messageSerializationService = messageSerializationService;
_queueService.RegisterConsumer(HandleMessageFromQueue);
}
public CallStatsService(ICallRepository callRepository, IQueueService queueService, IAgentService agentService, IQueueProvider queueProvider, IQueueStateHandler queueStateHandler)
{
_callRepository = callRepository;
_queueService = queueService;
_agentService = agentService;
_queueProvider = queueProvider;
_queueStateHandler = queueStateHandler;
}
public QueueSpecification(IQueueService queueService,
QualityUpgradableSpecification qualityUpgradableSpecification,
Logger logger)
{
_queueService = queueService;
_qualityUpgradableSpecification = qualityUpgradableSpecification;
_logger = logger;
}
public ProjectEditService(
EndowmentRepositories endowmentRepositories,
EndowmentHandlers endowmentHandlers,
IQueueService queueService)
{
_endowmentRepositories = endowmentRepositories;
_endowmentHandlers = endowmentHandlers;
_queueService = queueService;
}
public InteractionManager(Session session, IQueueService queueService, ITraceContext traceContext)
{
_traceContext = traceContext;
_interactionManager = InteractionsManager.GetInstance(session);
_queueService = queueService;
//We could use icelib to get the queue and interactions, but the AddIn API wraps things up to be a little simpler to use.
_myInteractionsQueue = _queueService.GetMyInteractions(new[] { InteractionAttributes.State });
}
static void DoGet(IQueueService proxy, string[] args)
{
try
{
bool getAll = false;
if (args[0] == "all")
{
getAll = true;
args = args.Skip(1).ToArray();
}
var aggregateId = args[0];
int version;
if (args.Length > 1)
version = int.Parse(args[1]);
else
{
if (getAll)
version = -1;
else
throw new ArgumentException("Version must be specified if exact version is requested");
}
if (getAll)
{
var results = proxy.GetAllNext(aggregateId, version);
if (results.Count() == 0)
{
Logger.Instance.Warn("There's no objects in aggregate '{0}' with version > {1}",
aggregateId, version);
}
else
{
foreach (var result in results)
Logger.Instance.Info(result.ToString());
}
}
else
{
object obj;
if (proxy.TryGetNext(aggregateId,version, out obj))
{
Logger.Instance.Info(obj.ToString());
}
else
{
Logger.Instance.Warn("Theres' no object in aggregate '{0}' with version {1}",aggregateId, version);
}
}
}
catch (Exception ex)
{
Logger.Instance.Error("Unhandled Exception", ex);
ShowUsage();
}
}
public TwilioVoiceController(IQueueStateHandler queueStateHandler, IAccountSettings accountSettings, ILogger logger, ICallService callService, IQueueService queueService, IQueueProvider queueProvider, IAgentService agentService)
{
_queueStateHandler = queueStateHandler;
_accountSettings = accountSettings;
_logger = logger;
_callService = callService;
_queueService = queueService;
_queueProvider = queueProvider;
_agentService = agentService;
}
public PullMessageRequestHandler()
{
_consumerManager = ObjectContainer.Resolve<ConsumerManager>();
_suspendedPullRequestManager = ObjectContainer.Resolve<SuspendedPullRequestManager>();
_messageService = ObjectContainer.Resolve<IMessageService>();
_queueService = ObjectContainer.Resolve<IQueueService>();
_offsetManager = ObjectContainer.Resolve<IOffsetManager>();
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
EmptyResponseData = new byte[0];
}
public ProjectService(
IQueueService queueService,
IProjectEditService projectEditService,
EndowmentHandlers endowmentHandlers,
EndowmentRepositories repositories)
{
_queueService = queueService;
_projectEditService = projectEditService;
_endowmentHandlers = endowmentHandlers;
_repositories = repositories;
}
private BrokerController(BrokerSetting setting)
{
Setting = setting ?? new BrokerSetting();
_consumerManager = ObjectContainer.Resolve<ConsumerManager>();
_messageStore = ObjectContainer.Resolve<IMessageStore>();
_offsetManager = ObjectContainer.Resolve<IOffsetManager>();
_queueService = ObjectContainer.Resolve<IQueueService>();
_messageService = ObjectContainer.Resolve<IMessageService>();
_suspendedPullRequestManager = ObjectContainer.Resolve<SuspendedPullRequestManager>();
_producerSocketRemotingServer = new SocketRemotingServer("EQueue.Broker.ProducerRemotingServer", Setting.ProducerIPEndPoint);
_consumerSocketRemotingServer = new SocketRemotingServer("EQueue.Broker.ConsumerRemotingServer", Setting.ConsumerIPEndPoint, this);
_adminSocketRemotingServer = new SocketRemotingServer("EQueue.Broker.AdminRemotingServer", Setting.AdminIPEndPoint);
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
RegisterRequestHandlers();
}
public InteractionSyncManager(IInteractionManager interactionManager, IDeviceManager deviceManager, IQueueService queueService, ITraceContext traceContext, IConnection connection)
{
_interactionManager = interactionManager;
_deviceManager = deviceManager;
_traceContext = traceContext;
_connection = connection;
_connection.UpChanged += OnConnectionUpChanged;
_deviceManager.CallAnsweredByDevice += OnCallAnsweredByDevice;
_deviceManager.CallEndedByDevice += OnCallEndedByDevice;
_deviceManager.MuteChanged += OnMuteChangedByDevice;
_deviceManager.OnCall += OnOnCall;
// _deviceManager.TalkButtonPressed += OnTalkButtonPressed;
_deviceManager.TalkButtonHeld += OnTalkButtonHeld;
_myInteractions = queueService.GetMyInteractions(new[] { InteractionAttributes.State, InteractionAttributes.Muted });
_myInteractions.InteractionAdded += OnInteractionAdded;
_myInteractions.InteractionChanged += OnInteractionChanged;
_myInteractions.InteractionRemoved += OnInteractionRemoved;
}
public TestSaveContact()
{
var contacts = new[]
{
new Contact
{
Id = 1,
FirstName = "First",
LastName = "Last",
Email = "*****@*****.**",
PhoneNumber = "555-1212"
},
}.ToDbSet();
_db = A.Fake<ContactDb>();
A.CallTo(() => _db.Contacts).Returns(contacts);
_appContext = A.Fake<AppContext>();
_queue = A.Fake<IQueueService>();
_mediator = A.Fake<IMediator>();
_handler = new SaveContact.Handler(_db, _appContext, _queue, _mediator);
}
public LogsController(IDepartmentsService departmentsService, IUsersService usersService, ICallsService callsService,
IDepartmentGroupsService departmentGroupsService, ICommunicationService communicationService, IQueueService queueService,
Model.Services.IAuthorizationService authorizationService, IWorkLogsService workLogsService, IEventAggregator eventAggregator)
{
_departmentsService = departmentsService;
_usersService = usersService;
_callsService = callsService;
_departmentGroupsService = departmentGroupsService;
_communicationService = communicationService;
_queueService = queueService;
_authorizationService = authorizationService;
_workLogsService = workLogsService;
_eventAggregator = eventAggregator;
}
static void DoPush(IQueueService proxy, string[] args)
{
try
{
proxy.Push(args[0], int.Parse(args[1]), args[2]);
}
catch (Exception ex)
{
Logger.Instance.Error("Unhandled Exception", ex);
ShowUsage();
}
}
public HoroscopeController(IHoroscopeGateway horoscopeGateway, IQueueService queueService)
{
_horoscopeGateway = horoscopeGateway;
_queueService = queueService;
}
public Handler(
IQueueService queueService)
{
_queueService = queueService;
}
public DataTransferController(IFileStorageServiceCommon fileStorageService,
IQueueService queueService)
{
this.fileStorageService = fileStorageService;
this.queueService = queueService;
}
public LogViewModel(IErrorService errorService, ILogInstanceManager logInstanceManager, IQueueService queueService)
{
this.errorService = errorService;
this.logInstanceManager = logInstanceManager;
this.queueService = queueService;
this.Title = Resources.LogViewModel_Title;
}
public CsvImporterService(IJobsService jobsService, ICloudStorageService cloudStorageService, IQueueService queueService)
{
_jobsService = jobsService;
_cloudStorageService = cloudStorageService;
_queueService = queueService;
}
public QueryTopicQueueInfoRequestHandler()
{
_binarySerializer = ObjectContainer.Resolve <IBinarySerializer>();
_queueService = ObjectContainer.Resolve <IQueueService>();
_offsetManager = ObjectContainer.Resolve <IOffsetManager>();
}
public ImportMessageBodyViewModel(IQueueService queueService, IDialogService dialogService)
{
_queueService = queueService;
_dialogService = dialogService;
UseDeadLetterQueue = true;
}
public NotInQueueSpecification(IQueueService queueService, Logger logger)
{
_queueService = queueService;
_logger = logger;
}
public CallStatsController(ICallStatsService callStatsService, IQueueStateHandler queueStateHandler, IQueueService queueService)
{
_callStatsService = callStatsService;
_queueStateHandler = queueStateHandler;
_queueService = queueService;
}
public QueueModule(ICommandExecutor commandExecutor, IQueueService queueService)
: base(commandExecutor)
{
_queueService = queueService;
GetResourceAll = GetQueue;
}
public async Task <Tuple <bool, string> > Process(CallEmailQueueItem item)
{
bool success = true;
string result = "";
_callEmailProvider = Bootstrapper.GetKernel().Resolve <ICallEmailProvider>();
if (!String.IsNullOrWhiteSpace(item?.EmailSettings?.Hostname))
{
CallEmailsResult emailResult = _callEmailProvider.GetAllCallEmailsFromServer(item.EmailSettings);
if (emailResult?.Emails != null && emailResult.Emails.Count > 0)
{
var calls = new List <Call>();
_callsService = Bootstrapper.GetKernel().Resolve <ICallsService>();
_queueService = Bootstrapper.GetKernel().Resolve <IQueueService>();
_departmentsService = Bootstrapper.GetKernel().Resolve <IDepartmentsService>();
_userProfileService = Bootstrapper.GetKernel().Resolve <IUserProfileService>();
_departmentSettingsService = Bootstrapper.GetKernel().Resolve <IDepartmentSettingsService>();
_unitsService = Bootstrapper.GetKernel().Resolve <IUnitsService>();
// Ran into an issue where the department users didn't come back. We can't put the email back in the POP
// email box so just added some simple retry logic here.
List <IdentityUser> departmentUsers = await _departmentsService.GetAllUsersForDepartmentAsync(item.EmailSettings.DepartmentId, true);
var profiles = await _userProfileService.GetAllProfilesForDepartmentAsync(item.EmailSettings.DepartmentId);
int retry = 0;
while (retry < 3 && departmentUsers == null)
{
Thread.Sleep(150);
departmentUsers = await _departmentsService.GetAllUsersForDepartmentAsync(item.EmailSettings.DepartmentId, true);
retry++;
}
foreach (var email in emailResult.Emails)
{
var activeCalls = await _callsService.GetActiveCallsByDepartmentAsync(item.EmailSettings.Department.DepartmentId);
var units = await _unitsService.GetUnitsForDepartmentAsync(item.EmailSettings.Department.DepartmentId);
var priorities = await _callsService.GetActiveCallPrioritiesForDepartmentAsync(item.EmailSettings.Department.DepartmentId);
int defaultPriority = (int)CallPriority.High;
if (priorities != null && priorities.Any())
{
var defaultPrio = priorities.FirstOrDefault(x => x.IsDefault && x.IsDeleted == false);
if (defaultPrio != null)
{
defaultPriority = defaultPrio.DepartmentCallPriorityId;
}
}
var call = _callsService.GenerateCallFromEmail(item.EmailSettings.FormatType, email,
item.EmailSettings.Department.ManagingUserId, departmentUsers, item.EmailSettings.Department, activeCalls, units, defaultPriority, priorities);
if (call != null)
{
call.DepartmentId = item.EmailSettings.DepartmentId;
if (!calls.Any(x => x.Name == call.Name && x.NatureOfCall == call.NatureOfCall))
{
calls.Add(call);
}
}
}
if (calls.Any())
{
var departmentTextNumber = await _departmentSettingsService.GetTextToCallNumberForDepartmentAsync(item.EmailSettings.DepartmentId);
foreach (var call in calls)
{
try
{
// Adding this in here to try and fix the error below with ObjectContext issues.
var newCall = CreateNewCallFromCall(call);
if (newCall.Dispatches != null && newCall.Dispatches.Any())
{
// We've been having this error here:
// The relationship between the two objects cannot be defined because they are attached to different ObjectContext objects.
// So I'm wrapping this in a try catch to prevent all calls form being dropped.
var savedCall = await _callsService.SaveCallAsync(newCall);
var cqi = new CallQueueItem();
cqi.Call = savedCall;
cqi.Profiles = profiles.Values.ToList();
cqi.DepartmentTextNumber = departmentTextNumber;
await _queueService.EnqueueCallBroadcastAsync(cqi);
}
}
catch (Exception ex)
{
result = ex.ToString();
Logging.LogException(ex);
}
}
}
await _departmentsService.SaveDepartmentEmailSettingsAsync(emailResult.EmailSettings);
_callsService = null;
_queueService = null;
_departmentsService = null;
_callEmailProvider = null;
_userProfileService = null;
_departmentSettingsService = null;
}
}
return(new Tuple <bool, string>(success, result));
}
public PaymentController(IQueueService queueService, ITransactionAppService transactionAppService, ICashFlowService cashFlowService)
{
_transactionAppService = transactionAppService;
_cashFlowService = cashFlowService;
}
public TwilioController(IDepartmentSettingsService departmentSettingsService, INumbersService numbersService,
ILimitsService limitsService, ICallsService callsService, IQueueService queueService, IDepartmentsService departmentsService,
IUserProfileService userProfileService, ITextCommandService textCommandService, IActionLogsService actionLogsService,
IUserStateService userStateService, ICommunicationService communicationService, IGeoLocationProvider geoLocationProvider,
IDepartmentGroupsService departmentGroupsService, ICustomStateService customStateService, IUnitsService unitsService)
{
_departmentSettingsService = departmentSettingsService;
_numbersService = numbersService;
_limitsService = limitsService;
_callsService = callsService;
_queueService = queueService;
_departmentsService = departmentsService;
_userProfileService = userProfileService;
_textCommandService = textCommandService;
_actionLogsService = actionLogsService;
_userStateService = userStateService;
_communicationService = communicationService;
_geoLocationProvider = geoLocationProvider;
_departmentGroupsService = departmentGroupsService;
_customStateService = customStateService;
_unitsService = unitsService;
}
public BuildingQueueController(IQueueService queueTable)
{
_queueTable = queueTable;
}
public SitesController(ISiteService siteService, IQueueService queueService)
{
this.siteService = siteService;
this.queueService = queueService;
}
public FascicleController(IFascicleService service, IDataUnitOfWork unitOfWork, ILogger logger, ICurrentIdentity currentIdentity, IQueueService queueService, ICQRSMessageMapper CQRSMapper,
IResolutionModelMapper mapper, IMapperUnitOfWork mapperUnitOfWork, IParameterEnvService parameterEnvService)
: base(service, unitOfWork, logger)
{
_unitOfWork = unitOfWork;
_currentIdentity = currentIdentity;
_cqrsMapper = CQRSMapper;
_queueService = queueService;
_logger = logger;
_mapper = mapper;
_mapperUnitOfwork = mapperUnitOfWork;
_parameterEnvService = parameterEnvService;
}
public JournalQueueTreeNodeViewModel(IEventAggregator eventAggregator, MessageQueue journalQueue, IQueueService queueService, IDialogService dialogService)
{
_eventAggregator = eventAggregator;
_journalQueue = journalQueue;
_queueService = queueService;
_dialogService = dialogService;
_eventAggregator.Subscribe(this);
}
public HomeController(IQueueService queueService)
{
_queueService = queueService;
}
public OrdersController(IOrdersProvider ordersProvider, IQueueService queueService, ILogger <OrdersController> logger)
{
this.ordersProvider = ordersProvider;
this.queueService = queueService;
this.logger = logger;
}
public SystemService(IUserSettingService userSettingService, ILog logService, IQueueService queueService)
{
this.log = logService;
this.queueService = queueService;
this.userSettingService = userSettingService;
}
public ConfigureConnectionViewModel(QueueConnectionContext queueConnectionContext, IQueueService queueService, IDialogService dialogService)
{
_queueConnectionContext = queueConnectionContext;
_queueService = queueService;
_dialogService = dialogService;
ComputerName = _queueConnectionContext.ComputerName;
}
public ProcessDepartmentDepartment_delete_others_normal(IRepositoryFactory departmentRepository, Func <string, IRepositoryFactory> repositoryAccessor, IQueueService queueService)
{
_repositoryAccessor = repositoryAccessor;
_repository = _repositoryAccessor("EF");
}
public CreateNewMessageViewModel(IQueueService queueService, IDialogService dialogService)
{
_queueService = queueService;
_dialogService = dialogService;
}
public ImagesController(IBlobService service, IQueueService queueService)
{
this.service = service;
this.queueService = queueService;
}
public GetTopicQueueIdsForProducerRequestHandler()
{
_queueService = ObjectContainer.Resolve<IQueueService>();
}
public ConsumingService(IQueueService queueService,
ILogger <ConsumingService> logger)
{
this.logger = logger;
this.queueService = queueService;
}
public SuspendedPullRequestManager()
{
_scheduleService = ObjectContainer.Resolve<IScheduleService>();
_queueService = ObjectContainer.Resolve<IQueueService>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
}
public async Task <ActionResult> Log(object request, [FromServices] IQueueService queue)
{
await queue.Send(request);
return(Ok());
}
public ImportMessageBodyViewModel(IQueueService queueService, IDialogService dialogService)
{
_queueService = queueService;
_dialogService = dialogService;
UseDeadLetterQueue = true;
}
public DownloadHub(IQueueService <DownloadRequestBM> queue, IFilenameDatabase filenameDatabase, IDownloadManagementService downloaderService)
{
this.downloadServiceQueue = queue;
this.filenameDatabase = filenameDatabase;
this.downloaderService = downloaderService;
}
public ServiceBusQueueServiceTests()
{
_serviceBusFactoryMock = new Mock <IServiceBusFactory>();
_queueService = new ServiceBusQueueService(_serviceBusFactoryMock.Object);
}
public ProxyService(IQueueService queueService)
{
this._queueService = queueService;
InitializeComponent();
}
public QueueManagerService(IQueueService queueService, DiscordSocketClient discordClient)
{
_queueService = queueService;
_discordClient = discordClient;
}
public NotInQueueSpecification(IQueueService queueService, Logger logger)
{
_queueService = queueService;
_logger = logger;
}
public HomeController(IImageService imageService, IQueueService<UploadedImage> queueService)
{
_imageService = imageService;
_queueService = queueService;
}
public AddQueueRequestHandler()
{
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_queueService = ObjectContainer.Resolve<IQueueService>();
}
public EmailController(IDepartmentSettingsService departmentSettingsService, INumbersService numbersService,
ILimitsService limitsService, ICallsService callsService, IQueueService queueService, IDepartmentsService departmentsService,
IUserProfileService userProfileService, ITextCommandService textCommandService, IActionLogsService actionLogsService,
IUserStateService userStateService, ICommunicationService communicationService, IDistributionListsService distributionListsService,
IUsersService usersService, IEmailService emailService, IDepartmentGroupsService departmentGroupsService, IMessageService messageService,
IFileService fileService, IUnitsService unitsService)
{
_departmentSettingsService = departmentSettingsService;
_numbersService = numbersService;
_limitsService = limitsService;
_callsService = callsService;
_queueService = queueService;
_departmentsService = departmentsService;
_userProfileService = userProfileService;
_textCommandService = textCommandService;
_actionLogsService = actionLogsService;
_userStateService = userStateService;
_communicationService = communicationService;
_distributionListsService = distributionListsService;
_usersService = usersService;
_emailService = emailService;
_departmentGroupsService = departmentGroupsService;
_messageService = messageService;
_fileService = fileService;
_unitsService = unitsService;
}
public QueueStateHandler(IQueueService queueService, ILogger logger, IQueueProvider queueProvider)
{
_queueService = queueService;
_logger = logger;
_queueProvider = queueProvider;
}
public OrderController(ILogger <OrderController> logger, IQueueService queueService, ITableService tableService)
{
_qService = queueService;
_tService = tableService;
_logger = logger;
}
